Chili Palmer
2558e2f49f
Some checks failed
Native code generation / deterministic (push) Failing after 2m36s
Imaging and meshing gate / native (push) Successful in 5m29s
JPEG 2000 feature / linux (push) Successful in 2m46s
Native Rust workspace compile / compile (push) Failing after 1m58s
Skia feature / linux (push) Successful in 31m14s
858 lines
32 KiB
Rust
858 lines
32 KiB
Rust
// @generated by tools/generate_lsl_tables.py; do not edit by hand.
|
|
#![allow(non_camel_case_types)]
|
|
#![allow(non_snake_case)]
|
|
#![allow(clippy::missing_errors_doc)]
|
|
#![allow(clippy::must_use_candidate)]
|
|
|
|
use std::ops::{Deref, DerefMut};
|
|
|
|
use libremetaverse_types::compat::{Object, UnicodeCategory};
|
|
|
|
use crate::{
|
|
CharacterMatcher, Dfa, DfaAccept, DfaState, Error, ErrorHandler, Grammar, Lexer, LexerAction,
|
|
Parser, ResWds, SYMBOL, TOKEN, TokenDefinition, UnicodeClass, YyLexer, YyParser,
|
|
};
|
|
|
|
pub const LSL_GENERATOR_SOURCE_COMMIT: &str = "2aa70bb68513b39795da5d13c88f31b86e85a3ba";
|
|
pub const LSL_GENERATOR_SOURCE_PARSER: &str = "LibreMetaverse.LslTools/YYClass/yycs0syntax.cs";
|
|
pub const LSL_GENERATOR_SOURCE_LEXER: &str = "LibreMetaverse.LslTools/YYClass/yycs0tokens.cs";
|
|
pub const LSL_GENERATOR_SOURCE_LICENSE: &str = "BSD-3-Clause";
|
|
pub const LSL_GENERATOR_SERIALIZATION_VERSION: &str = "4.5";
|
|
pub const GENERATED_PARSER_DATA: &[i32] = &[
|
|
1, 19, 2, 22, 2, 1, 3, 3, 1, 4, 4, 1, 4, 5, 1, 3, 6, 1, 2, 7, 1, 3, 8, 1, 5, 9, 1, 9, 10, 1, 6,
|
|
11, 1, 6, 12, 1, 6, 13, 1, 6, 14, 1, 6, 15, 1, 6, 16, 0, 6, 17, 0, 5, 18, 0, 4, 19, 0, 9, 20,
|
|
0, 4, 21, 0, 4, 22, 0, 8, 23, 0, 4, 25, 1, 19, 3, 16, 20, 16, 2, 16, 0, 3, 16, 2, 16, 18, 4,
|
|
16, 2, 16, 21, 5, 17, 0, 6, 17, 2, 17, 18, 7, 20, 5, 23, 12, 17, 13, 22, 8, 21, 4, 23, 12, 17,
|
|
13, 9, 22, 0, 10, 22, 5, 8, 3, 12, 17, 13, 11, 22, 5, 8, 4, 12, 17, 13, 12, 23, 1, 6, 13, 23,
|
|
4, 6, 14, 17, 15, 14, 18, 1, 6, 15, 18, 1, 7, 16, 18, 1, 9, 17, 18, 1, 3, 18, 18, 1, 4, 19, 18,
|
|
4, 4, 14, 17, 15, 20, 18, 1, 8, 21, 18, 2, 5, 23, 22, 18, 2, 5, 6, 23, 18, 3, 12, 17, 13, 24,
|
|
18, 3, 10, 16, 11, 25, 18, 3, 14, 17, 15,
|
|
];
|
|
|
|
pub fn generated_symbol_name(number: i32) -> Option<&'static str> {
|
|
match number {
|
|
2 => Some("EOF"),
|
|
3 => Some("BASE"),
|
|
4 => Some("THIS"),
|
|
5 => Some("NEW"),
|
|
6 => Some("ID"),
|
|
7 => Some("ANY"),
|
|
8 => Some("COLON"),
|
|
9 => Some("SEMICOLON"),
|
|
10 => Some("LBRACE"),
|
|
11 => Some("RBRACE"),
|
|
12 => Some("LPAREN"),
|
|
13 => Some("RPAREN"),
|
|
14 => Some("LBRACK"),
|
|
15 => Some("RBRACK"),
|
|
16 => Some("GStuff"),
|
|
17 => Some("Stuff"),
|
|
18 => Some("Item"),
|
|
19 => Some("ClassBody"),
|
|
20 => Some("Cons"),
|
|
21 => Some("Call"),
|
|
22 => Some("BaseCall"),
|
|
23 => Some("Name"),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn generated_parser() -> Result<YyParser, Error> {
|
|
let mut grammar = Grammar::new(19, 2)?;
|
|
grammar.add_symbol("EOF", 2, true)?;
|
|
grammar.add_symbol("BASE", 3, true)?;
|
|
grammar.add_symbol("THIS", 4, true)?;
|
|
grammar.add_symbol("NEW", 5, true)?;
|
|
grammar.add_symbol("ID", 6, true)?;
|
|
grammar.add_symbol("ANY", 7, true)?;
|
|
grammar.add_symbol("COLON", 8, true)?;
|
|
grammar.add_symbol("SEMICOLON", 9, true)?;
|
|
grammar.add_symbol("LBRACE", 10, true)?;
|
|
grammar.add_symbol("RBRACE", 11, true)?;
|
|
grammar.add_symbol("LPAREN", 12, true)?;
|
|
grammar.add_symbol("RPAREN", 13, true)?;
|
|
grammar.add_symbol("LBRACK", 14, true)?;
|
|
grammar.add_symbol("RBRACK", 15, true)?;
|
|
grammar.add_symbol("GStuff", 16, false)?;
|
|
grammar.add_symbol("Stuff", 17, false)?;
|
|
grammar.add_symbol("Item", 18, false)?;
|
|
grammar.add_symbol("ClassBody", 19, false)?;
|
|
grammar.add_symbol("Cons", 20, false)?;
|
|
grammar.add_symbol("Call", 21, false)?;
|
|
grammar.add_symbol("BaseCall", 22, false)?;
|
|
grammar.add_symbol("Name", 23, false)?;
|
|
grammar.add_production(19, vec![16, 20, 16])?;
|
|
grammar.add_production(16, vec![])?;
|
|
grammar.add_production(16, vec![16, 18])?;
|
|
grammar.add_production(16, vec![16, 21])?;
|
|
grammar.add_production(17, vec![])?;
|
|
grammar.add_production(17, vec![17, 18])?;
|
|
grammar.add_production(20, vec![23, 12, 17, 13, 22])?;
|
|
grammar.add_production(21, vec![23, 12, 17, 13])?;
|
|
grammar.add_production(22, vec![])?;
|
|
grammar.add_production(22, vec![8, 3, 12, 17, 13])?;
|
|
grammar.add_production(22, vec![8, 4, 12, 17, 13])?;
|
|
grammar.add_production(23, vec![6])?;
|
|
grammar.add_production(23, vec![6, 14, 17, 15])?;
|
|
grammar.add_production(18, vec![6])?;
|
|
grammar.add_production(18, vec![7])?;
|
|
grammar.add_production(18, vec![9])?;
|
|
grammar.add_production(18, vec![3])?;
|
|
grammar.add_production(18, vec![4])?;
|
|
grammar.add_production(18, vec![4, 14, 17, 15])?;
|
|
grammar.add_production(18, vec![8])?;
|
|
grammar.add_production(18, vec![5, 23])?;
|
|
grammar.add_production(18, vec![5, 6])?;
|
|
grammar.add_production(18, vec![12, 17, 13])?;
|
|
grammar.add_production(18, vec![10, 16, 11])?;
|
|
grammar.add_production(18, vec![14, 17, 15])?;
|
|
let mut parser = grammar.build()?;
|
|
parser.arr = GENERATED_PARSER_DATA.to_vec();
|
|
Ok(parser)
|
|
}
|
|
|
|
fn accept(name: &str, number: i32, action: LexerAction, action_number: i32) -> DfaAccept {
|
|
DfaAccept {
|
|
token: TokenDefinition {
|
|
name: name.to_owned(),
|
|
number,
|
|
},
|
|
action,
|
|
action_number,
|
|
reserved_words: (name == "ID").then(|| "ID".to_owned()),
|
|
}
|
|
}
|
|
|
|
pub fn generated_lexer_with_handler(error_handler: ErrorHandler) -> Result<YyLexer, Error> {
|
|
let punctuation = [
|
|
(58, "COLON", 8),
|
|
(59, "SEMICOLON", 9),
|
|
(123, "LBRACE", 10),
|
|
(125, "RBRACE", 11),
|
|
(40, "LPAREN", 12),
|
|
(41, "RPAREN", 13),
|
|
(91, "LBRACK", 14),
|
|
(93, "RBRACK", 15),
|
|
];
|
|
let punctuation_start = 3usize;
|
|
let any_state = punctuation_start + punctuation.len();
|
|
let mut states = vec![DfaState::default(); any_state + 1];
|
|
states[0] = states[0]
|
|
.clone()
|
|
.transition(CharacterMatcher::UnicodeClass(UnicodeClass::WhiteSpace), 1)
|
|
.transition(CharacterMatcher::UnicodeClass(UnicodeClass::Letter), 2)
|
|
.transition(CharacterMatcher::Exact(u16::from(b'_')), 2);
|
|
for (offset, (unit, _, _)) in punctuation.iter().enumerate() {
|
|
states[0]
|
|
.transitions
|
|
.push((CharacterMatcher::Exact(*unit), punctuation_start + offset));
|
|
}
|
|
states[0]
|
|
.transitions
|
|
.push((CharacterMatcher::Any, any_state));
|
|
states[1] = states[1]
|
|
.clone()
|
|
.transition(CharacterMatcher::UnicodeClass(UnicodeClass::WhiteSpace), 1)
|
|
.accepting(accept("ANY", 7, LexerAction::Skip, -1));
|
|
states[2] = states[2]
|
|
.clone()
|
|
.transition(CharacterMatcher::UnicodeClass(UnicodeClass::Letter), 2)
|
|
.transition(CharacterMatcher::UnicodeClass(UnicodeClass::Number), 2)
|
|
.transition(CharacterMatcher::Exact(u16::from(b'_')), 2)
|
|
.accepting(accept("ID", 6, LexerAction::Emit, 0));
|
|
for (offset, (_, name, number)) in punctuation.iter().enumerate() {
|
|
states[punctuation_start + offset] =
|
|
DfaState::default().accepting(accept(name, *number, LexerAction::Emit, *number));
|
|
}
|
|
states[any_state] = DfaState::default().accepting(accept("ANY", 7, LexerAction::Emit, 1));
|
|
let mut lexer = YyLexer::new(error_handler)?;
|
|
lexer.set_start_dfa("YYINITIAL", Dfa::from_states(states, 0)?)?;
|
|
lexer.set_reserved_words(
|
|
"ID",
|
|
ResWds::from_pairs(
|
|
[
|
|
("base", TokenDefinition::new("BASE", 3)?),
|
|
("this", TokenDefinition::new("THIS", 4)?),
|
|
("new", TokenDefinition::new("NEW", 5)?),
|
|
],
|
|
false,
|
|
)?,
|
|
)?;
|
|
lexer.using_eof = true;
|
|
for (name, number) in [
|
|
("EOF", 2),
|
|
("BASE", 3),
|
|
("THIS", 4),
|
|
("NEW", 5),
|
|
("ID", 6),
|
|
("ANY", 7),
|
|
("COLON", 8),
|
|
("SEMICOLON", 9),
|
|
("LBRACE", 10),
|
|
("RBRACE", 11),
|
|
("LPAREN", 12),
|
|
("RPAREN", 13),
|
|
("LBRACK", 14),
|
|
("RBRACK", 15),
|
|
] {
|
|
lexer
|
|
.tokens
|
|
.0
|
|
.insert(Object::String(name.to_owned()), Object::Integer(number));
|
|
}
|
|
let _ = lexer.using_cat(UnicodeCategory(0))?;
|
|
Ok(lexer)
|
|
}
|
|
|
|
pub fn generated_lexer() -> Result<YyLexer, Error> {
|
|
generated_lexer_with_handler(ErrorHandler::new_with_boolean(false)?)
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct GeneratedLexerToken<const NUMBER: i32>(TOKEN);
|
|
|
|
impl<const NUMBER: i32> GeneratedLexerToken<NUMBER> {
|
|
pub fn new(lexer: Lexer) -> Result<Self, Error> {
|
|
let name = generated_symbol_name(NUMBER).ok_or(Error::Argument)?;
|
|
Ok(Self(TOKEN::generated_with_lexer(lexer, name, NUMBER)?))
|
|
}
|
|
pub fn yyname(&self) -> String {
|
|
self.0.yyname()
|
|
}
|
|
pub const fn yynum(&self) -> i32 {
|
|
NUMBER
|
|
}
|
|
pub fn yytext(&self) -> String {
|
|
self.0.yytext()
|
|
}
|
|
}
|
|
|
|
impl<const NUMBER: i32> Deref for GeneratedLexerToken<NUMBER> {
|
|
type Target = TOKEN;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl<const NUMBER: i32> DerefMut for GeneratedLexerToken<NUMBER> {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
pub type BASE = GeneratedLexerToken<3>;
|
|
pub type THIS = GeneratedLexerToken<4>;
|
|
pub type NEW = GeneratedLexerToken<5>;
|
|
pub type ID = GeneratedLexerToken<6>;
|
|
pub type ANY = GeneratedLexerToken<7>;
|
|
pub type COLON = GeneratedLexerToken<8>;
|
|
pub type SEMICOLON = GeneratedLexerToken<9>;
|
|
pub type LBRACE = GeneratedLexerToken<10>;
|
|
pub type RBRACE = GeneratedLexerToken<11>;
|
|
pub type LPAREN = GeneratedLexerToken<12>;
|
|
pub type RPAREN = GeneratedLexerToken<13>;
|
|
pub type LBRACK = GeneratedLexerToken<14>;
|
|
pub type RBRACK = GeneratedLexerToken<15>;
|
|
|
|
fn generated_parser_identity(generated: i32) -> Option<(&'static str, i32)> {
|
|
match generated {
|
|
27..=35 => Some(("GStuff", 16)),
|
|
36..=41 => Some(("Stuff", 17)),
|
|
63..=98 => Some(("Item", 18)),
|
|
24..=26 => Some(("ClassBody", 19)),
|
|
42..=44 => Some(("Cons", 20)),
|
|
45..=47 => Some(("Call", 21)),
|
|
48..=56 => Some(("BaseCall", 22)),
|
|
57..=62 => Some(("Name", 23)),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn stack_text(parser: &Parser, index: i32) -> Result<String, Error> {
|
|
Ok(parser.stack_at(index)?.m_value.raw_text())
|
|
}
|
|
|
|
fn generated_semantic_text(generated: i32, parser: &Parser) -> Result<String, Error> {
|
|
Ok(match generated {
|
|
26 => stack_text(parser, 1)?,
|
|
32 | 35 | 41 => format!("{}{}", stack_text(parser, 1)?, stack_text(parser, 0)?),
|
|
44 => format!(
|
|
"{}({}){}",
|
|
stack_text(parser, 4)?.trim(),
|
|
stack_text(parser, 2)?,
|
|
stack_text(parser, 0)?
|
|
),
|
|
47 => format!(
|
|
"{}({})",
|
|
stack_text(parser, 3)?.trim(),
|
|
stack_text(parser, 1)?
|
|
),
|
|
53 => format!("base{}", stack_text(parser, 1)?),
|
|
56 => format!("this{}", stack_text(parser, 1)?),
|
|
59 => format!(" {} ", stack_text(parser, 0)?),
|
|
62 => format!("{}[{}]", stack_text(parser, 3)?, stack_text(parser, 1)?),
|
|
65 | 68 => stack_text(parser, 0)?,
|
|
71 => ";\n".to_owned(),
|
|
74 => " base ".to_owned(),
|
|
77 => " this ".to_owned(),
|
|
80 => format!(" this[{}]", stack_text(parser, 1)?),
|
|
83 => ":".to_owned(),
|
|
86 | 89 => format!(" new {}", stack_text(parser, 0)?),
|
|
92 => format!("({})", stack_text(parser, 1)?),
|
|
95 => format!("{{{}}}\n", stack_text(parser, 1)?),
|
|
98 => format!("[{}]", stack_text(parser, 1)?),
|
|
_ => String::new(),
|
|
})
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct GeneratedParserSymbol<const GENERATED: i32>(TOKEN);
|
|
|
|
impl<const GENERATED: i32> GeneratedParserSymbol<GENERATED> {
|
|
pub fn new(parser: Parser) -> Result<Self, Error> {
|
|
let (name, number) = generated_parser_identity(GENERATED).ok_or(Error::Argument)?;
|
|
let text = generated_semantic_text(GENERATED, &parser)?;
|
|
Ok(Self(TOKEN::generated_with_parser(
|
|
parser, name, number, text,
|
|
)?))
|
|
}
|
|
pub fn yyname(&self) -> String {
|
|
self.0.yyname()
|
|
}
|
|
pub fn yynum(&self) -> i32 {
|
|
self.0.yynum()
|
|
}
|
|
pub fn yytext(&self) -> String {
|
|
self.0.yytext()
|
|
}
|
|
}
|
|
|
|
impl<const GENERATED: i32> Deref for GeneratedParserSymbol<GENERATED> {
|
|
type Target = TOKEN;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl<const GENERATED: i32> DerefMut for GeneratedParserSymbol<GENERATED> {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
pub type ClassBody_1 = GeneratedParserSymbol<24>;
|
|
pub type ClassBody_2 = GeneratedParserSymbol<25>;
|
|
pub type ClassBody_2_1 = GeneratedParserSymbol<26>;
|
|
pub type GStuff_1 = GeneratedParserSymbol<27>;
|
|
pub type GStuff_2 = GeneratedParserSymbol<28>;
|
|
pub type GStuff_2_1 = GeneratedParserSymbol<29>;
|
|
pub type GStuff_3 = GeneratedParserSymbol<30>;
|
|
pub type GStuff_4 = GeneratedParserSymbol<31>;
|
|
pub type GStuff_4_1 = GeneratedParserSymbol<32>;
|
|
pub type GStuff_5 = GeneratedParserSymbol<33>;
|
|
pub type GStuff_6 = GeneratedParserSymbol<34>;
|
|
pub type GStuff_6_1 = GeneratedParserSymbol<35>;
|
|
pub type Stuff_1 = GeneratedParserSymbol<36>;
|
|
pub type Stuff_2 = GeneratedParserSymbol<37>;
|
|
pub type Stuff_2_1 = GeneratedParserSymbol<38>;
|
|
pub type Stuff_3 = GeneratedParserSymbol<39>;
|
|
pub type Stuff_4 = GeneratedParserSymbol<40>;
|
|
pub type Stuff_4_1 = GeneratedParserSymbol<41>;
|
|
pub type Cons_1 = GeneratedParserSymbol<42>;
|
|
pub type Cons_2 = GeneratedParserSymbol<43>;
|
|
pub type Cons_2_1 = GeneratedParserSymbol<44>;
|
|
pub type Call_1 = GeneratedParserSymbol<45>;
|
|
pub type Call_2 = GeneratedParserSymbol<46>;
|
|
pub type Call_2_1 = GeneratedParserSymbol<47>;
|
|
pub type BaseCall_1 = GeneratedParserSymbol<48>;
|
|
pub type BaseCall_2 = GeneratedParserSymbol<49>;
|
|
pub type BaseCall_2_1 = GeneratedParserSymbol<50>;
|
|
pub type BaseCall_3 = GeneratedParserSymbol<51>;
|
|
pub type BaseCall_4 = GeneratedParserSymbol<52>;
|
|
pub type BaseCall_4_1 = GeneratedParserSymbol<53>;
|
|
pub type BaseCall_5 = GeneratedParserSymbol<54>;
|
|
pub type BaseCall_6 = GeneratedParserSymbol<55>;
|
|
pub type BaseCall_6_1 = GeneratedParserSymbol<56>;
|
|
pub type Name_1 = GeneratedParserSymbol<57>;
|
|
pub type Name_2 = GeneratedParserSymbol<58>;
|
|
pub type Name_2_1 = GeneratedParserSymbol<59>;
|
|
pub type Name_3 = GeneratedParserSymbol<60>;
|
|
pub type Name_4 = GeneratedParserSymbol<61>;
|
|
pub type Name_4_1 = GeneratedParserSymbol<62>;
|
|
pub type Item_1 = GeneratedParserSymbol<63>;
|
|
pub type Item_2 = GeneratedParserSymbol<64>;
|
|
pub type Item_2_1 = GeneratedParserSymbol<65>;
|
|
pub type Item_3 = GeneratedParserSymbol<66>;
|
|
pub type Item_4 = GeneratedParserSymbol<67>;
|
|
pub type Item_4_1 = GeneratedParserSymbol<68>;
|
|
pub type Item_5 = GeneratedParserSymbol<69>;
|
|
pub type Item_6 = GeneratedParserSymbol<70>;
|
|
pub type Item_6_1 = GeneratedParserSymbol<71>;
|
|
pub type Item_7 = GeneratedParserSymbol<72>;
|
|
pub type Item_8 = GeneratedParserSymbol<73>;
|
|
pub type Item_8_1 = GeneratedParserSymbol<74>;
|
|
pub type Item_9 = GeneratedParserSymbol<75>;
|
|
pub type Item_10 = GeneratedParserSymbol<76>;
|
|
pub type Item_10_1 = GeneratedParserSymbol<77>;
|
|
pub type Item_11 = GeneratedParserSymbol<78>;
|
|
pub type Item_12 = GeneratedParserSymbol<79>;
|
|
pub type Item_12_1 = GeneratedParserSymbol<80>;
|
|
pub type Item_13 = GeneratedParserSymbol<81>;
|
|
pub type Item_14 = GeneratedParserSymbol<82>;
|
|
pub type Item_14_1 = GeneratedParserSymbol<83>;
|
|
pub type Item_15 = GeneratedParserSymbol<84>;
|
|
pub type Item_16 = GeneratedParserSymbol<85>;
|
|
pub type Item_16_1 = GeneratedParserSymbol<86>;
|
|
pub type Item_17 = GeneratedParserSymbol<87>;
|
|
pub type Item_18 = GeneratedParserSymbol<88>;
|
|
pub type Item_18_1 = GeneratedParserSymbol<89>;
|
|
pub type Item_19 = GeneratedParserSymbol<90>;
|
|
pub type Item_20 = GeneratedParserSymbol<91>;
|
|
pub type Item_20_1 = GeneratedParserSymbol<92>;
|
|
pub type Item_21 = GeneratedParserSymbol<93>;
|
|
pub type Item_22 = GeneratedParserSymbol<94>;
|
|
pub type Item_22_1 = GeneratedParserSymbol<95>;
|
|
pub type Item_23 = GeneratedParserSymbol<96>;
|
|
pub type Item_24 = GeneratedParserSymbol<97>;
|
|
pub type Item_24_1 = GeneratedParserSymbol<98>;
|
|
pub type GStuff = GeneratedParserSymbol<27>;
|
|
pub type Stuff = GeneratedParserSymbol<36>;
|
|
pub type Item = GeneratedParserSymbol<63>;
|
|
pub type ClassBody = GeneratedParserSymbol<24>;
|
|
pub type Cons = GeneratedParserSymbol<42>;
|
|
pub type Call = GeneratedParserSymbol<45>;
|
|
pub type BaseCall = GeneratedParserSymbol<48>;
|
|
pub type Name = GeneratedParserSymbol<57>;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct yycs0syntax(pub YyParser);
|
|
impl yycs0syntax {
|
|
pub fn new() -> Result<Self, Error> {
|
|
Ok(Self(generated_parser()?))
|
|
}
|
|
pub fn action(&self, parser: Parser, symbol: SYMBOL, action: i32) -> Result<Object, Error> {
|
|
self.0.action(parser, symbol, action)
|
|
}
|
|
pub fn class_body_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ClassBody_1::new(parser)?))
|
|
}
|
|
pub fn class_body_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ClassBody_2::new(parser)?))
|
|
}
|
|
pub fn class_body_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ClassBody_2_1::new(parser)?))
|
|
}
|
|
pub fn g_stuff_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_1::new(parser)?))
|
|
}
|
|
pub fn g_stuff_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_2::new(parser)?))
|
|
}
|
|
pub fn g_stuff_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_2_1::new(parser)?))
|
|
}
|
|
pub fn g_stuff_3_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_3::new(parser)?))
|
|
}
|
|
pub fn g_stuff_4_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_4::new(parser)?))
|
|
}
|
|
pub fn g_stuff_4_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_4_1::new(parser)?))
|
|
}
|
|
pub fn g_stuff_5_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_5::new(parser)?))
|
|
}
|
|
pub fn g_stuff_6_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_6::new(parser)?))
|
|
}
|
|
pub fn g_stuff_6_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff_6_1::new(parser)?))
|
|
}
|
|
pub fn stuff_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_1::new(parser)?))
|
|
}
|
|
pub fn stuff_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_2::new(parser)?))
|
|
}
|
|
pub fn stuff_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_2_1::new(parser)?))
|
|
}
|
|
pub fn stuff_3_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_3::new(parser)?))
|
|
}
|
|
pub fn stuff_4_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_4::new(parser)?))
|
|
}
|
|
pub fn stuff_4_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff_4_1::new(parser)?))
|
|
}
|
|
pub fn cons_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Cons_1::new(parser)?))
|
|
}
|
|
pub fn cons_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Cons_2::new(parser)?))
|
|
}
|
|
pub fn cons_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Cons_2_1::new(parser)?))
|
|
}
|
|
pub fn call_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Call_1::new(parser)?))
|
|
}
|
|
pub fn call_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Call_2::new(parser)?))
|
|
}
|
|
pub fn call_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Call_2_1::new(parser)?))
|
|
}
|
|
pub fn base_call_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_1::new(parser)?))
|
|
}
|
|
pub fn base_call_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_2::new(parser)?))
|
|
}
|
|
pub fn base_call_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_2_1::new(parser)?))
|
|
}
|
|
pub fn base_call_3_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_3::new(parser)?))
|
|
}
|
|
pub fn base_call_4_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_4::new(parser)?))
|
|
}
|
|
pub fn base_call_4_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_4_1::new(parser)?))
|
|
}
|
|
pub fn base_call_5_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_5::new(parser)?))
|
|
}
|
|
pub fn base_call_6_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_6::new(parser)?))
|
|
}
|
|
pub fn base_call_6_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall_6_1::new(parser)?))
|
|
}
|
|
pub fn name_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_1::new(parser)?))
|
|
}
|
|
pub fn name_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_2::new(parser)?))
|
|
}
|
|
pub fn name_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_2_1::new(parser)?))
|
|
}
|
|
pub fn name_3_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_3::new(parser)?))
|
|
}
|
|
pub fn name_4_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_4::new(parser)?))
|
|
}
|
|
pub fn name_4_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name_4_1::new(parser)?))
|
|
}
|
|
pub fn item_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_1::new(parser)?))
|
|
}
|
|
pub fn item_2_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_2::new(parser)?))
|
|
}
|
|
pub fn item_2_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_2_1::new(parser)?))
|
|
}
|
|
pub fn item_3_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_3::new(parser)?))
|
|
}
|
|
pub fn item_4_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_4::new(parser)?))
|
|
}
|
|
pub fn item_4_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_4_1::new(parser)?))
|
|
}
|
|
pub fn item_5_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_5::new(parser)?))
|
|
}
|
|
pub fn item_6_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_6::new(parser)?))
|
|
}
|
|
pub fn item_6_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_6_1::new(parser)?))
|
|
}
|
|
pub fn item_7_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_7::new(parser)?))
|
|
}
|
|
pub fn item_8_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_8::new(parser)?))
|
|
}
|
|
pub fn item_8_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_8_1::new(parser)?))
|
|
}
|
|
pub fn item_9_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_9::new(parser)?))
|
|
}
|
|
pub fn item_10_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_10::new(parser)?))
|
|
}
|
|
pub fn item_10_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_10_1::new(parser)?))
|
|
}
|
|
pub fn item_11_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_11::new(parser)?))
|
|
}
|
|
pub fn item_12_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_12::new(parser)?))
|
|
}
|
|
pub fn item_12_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_12_1::new(parser)?))
|
|
}
|
|
pub fn item_13_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_13::new(parser)?))
|
|
}
|
|
pub fn item_14_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_14::new(parser)?))
|
|
}
|
|
pub fn item_14_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_14_1::new(parser)?))
|
|
}
|
|
pub fn item_15_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_15::new(parser)?))
|
|
}
|
|
pub fn item_16_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_16::new(parser)?))
|
|
}
|
|
pub fn item_16_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_16_1::new(parser)?))
|
|
}
|
|
pub fn item_17_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_17::new(parser)?))
|
|
}
|
|
pub fn item_18_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_18::new(parser)?))
|
|
}
|
|
pub fn item_18_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_18_1::new(parser)?))
|
|
}
|
|
pub fn item_19_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_19::new(parser)?))
|
|
}
|
|
pub fn item_20_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_20::new(parser)?))
|
|
}
|
|
pub fn item_20_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_20_1::new(parser)?))
|
|
}
|
|
pub fn item_21_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_21::new(parser)?))
|
|
}
|
|
pub fn item_22_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_22::new(parser)?))
|
|
}
|
|
pub fn item_22_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_22_1::new(parser)?))
|
|
}
|
|
pub fn item_23_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_23::new(parser)?))
|
|
}
|
|
pub fn item_24_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_24::new(parser)?))
|
|
}
|
|
pub fn item_24_1_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item_24_1::new(parser)?))
|
|
}
|
|
pub fn g_stuff_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(GStuff::new(parser)?))
|
|
}
|
|
pub fn stuff_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Stuff::new(parser)?))
|
|
}
|
|
pub fn item_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Item::new(parser)?))
|
|
}
|
|
pub fn class_body_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ClassBody::new(parser)?))
|
|
}
|
|
pub fn cons_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Cons::new(parser)?))
|
|
}
|
|
pub fn call_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Call::new(parser)?))
|
|
}
|
|
pub fn base_call_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BaseCall::new(parser)?))
|
|
}
|
|
pub fn name_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(Name::new(parser)?))
|
|
}
|
|
pub fn error_factory(parser: Parser) -> Result<Object, Error> {
|
|
Ok(Object::opaque(crate::LslError::new_with_parser(parser)?))
|
|
}
|
|
}
|
|
impl Deref for yycs0syntax {
|
|
type Target = YyParser;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl DerefMut for yycs0syntax {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct yycs0tokens(pub YyLexer);
|
|
impl yycs0tokens {
|
|
pub fn new(error_handler: ErrorHandler) -> Result<Self, Error> {
|
|
Ok(Self(generated_lexer_with_handler(error_handler)?))
|
|
}
|
|
pub fn base_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(BASE::new(lexer)?))
|
|
}
|
|
pub fn this_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(THIS::new(lexer)?))
|
|
}
|
|
pub fn new_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(NEW::new(lexer)?))
|
|
}
|
|
pub fn id_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ID::new(lexer)?))
|
|
}
|
|
pub fn any_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(ANY::new(lexer)?))
|
|
}
|
|
pub fn colon_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(COLON::new(lexer)?))
|
|
}
|
|
pub fn semicolon_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(SEMICOLON::new(lexer)?))
|
|
}
|
|
pub fn lbrace_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(LBRACE::new(lexer)?))
|
|
}
|
|
pub fn rbrace_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(RBRACE::new(lexer)?))
|
|
}
|
|
pub fn lparen_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(LPAREN::new(lexer)?))
|
|
}
|
|
pub fn rparen_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(RPAREN::new(lexer)?))
|
|
}
|
|
pub fn lbrack_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(LBRACK::new(lexer)?))
|
|
}
|
|
pub fn rbrack_factory(lexer: Lexer) -> Result<Object, Error> {
|
|
Ok(Object::opaque(RBRACK::new(lexer)?))
|
|
}
|
|
pub fn old_action(
|
|
&self,
|
|
lexer: Lexer,
|
|
yytext: &mut String,
|
|
action: i32,
|
|
reject: &mut bool,
|
|
) -> Result<TOKEN, Error> {
|
|
if matches!(action, 8 | 55 | 74) {
|
|
match action {
|
|
8 => "yym.yy_begin",
|
|
55 => "((cs0tokens)yym)",
|
|
_ => "((cs0syntax)yyq)",
|
|
}
|
|
.clone_into(yytext);
|
|
return TOKEN::generated_with_lexer(lexer, "ANY", 7);
|
|
}
|
|
*reject = true;
|
|
Err(Error::InvalidOperation)
|
|
}
|
|
}
|
|
impl Deref for yycs0tokens {
|
|
type Target = YyLexer;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl DerefMut for yycs0tokens {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct cs0tokens {
|
|
pub out: String,
|
|
pub lexer: Lexer,
|
|
}
|
|
impl cs0tokens {
|
|
pub fn new() -> Result<Self, Error> {
|
|
Self::new_with_yy_lexer(generated_lexer()?)
|
|
}
|
|
pub fn new_with_constructor() -> Result<Self, Error> {
|
|
Self::new()
|
|
}
|
|
pub fn new_with_error_handler(handler: ErrorHandler) -> Result<Self, Error> {
|
|
Self::new_with_yy_lexer(generated_lexer_with_handler(handler)?)
|
|
}
|
|
pub fn new_with_yy_lexer(tokens: YyLexer) -> Result<Self, Error> {
|
|
Ok(Self {
|
|
out: String::new(),
|
|
lexer: Lexer::new(tokens)?,
|
|
})
|
|
}
|
|
}
|
|
impl Deref for cs0tokens {
|
|
type Target = Lexer;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.lexer
|
|
}
|
|
}
|
|
impl DerefMut for cs0tokens {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.lexer
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct cs0syntax {
|
|
pub out: String,
|
|
pub cls: String,
|
|
pub par: String,
|
|
pub ctx: String,
|
|
pub defconseen: bool,
|
|
pub parser: Parser,
|
|
}
|
|
impl cs0syntax {
|
|
pub fn new() -> Result<Self, Error> {
|
|
Self::new_with_yy_parser(generated_parser()?)
|
|
}
|
|
pub fn new_with_constructor() -> Result<Self, Error> {
|
|
Self::new()
|
|
}
|
|
pub fn new_with_yy_parser(symbols: YyParser) -> Result<Self, Error> {
|
|
let lexer = Lexer::new(generated_lexer()?)?;
|
|
Self::from_parts(symbols, lexer)
|
|
}
|
|
pub fn new_with_yy_parser_error_handler(
|
|
mut symbols: YyParser,
|
|
handler: ErrorHandler,
|
|
) -> Result<Self, Error> {
|
|
symbols.erh = handler.clone();
|
|
let lexer = Lexer::new(generated_lexer_with_handler(handler)?)?;
|
|
Self::from_parts(symbols, lexer)
|
|
}
|
|
fn from_parts(symbols: YyParser, lexer: Lexer) -> Result<Self, Error> {
|
|
Ok(Self {
|
|
out: String::new(),
|
|
cls: String::new(),
|
|
par: String::new(),
|
|
ctx: String::new(),
|
|
defconseen: false,
|
|
parser: Parser::new(symbols, lexer)?,
|
|
})
|
|
}
|
|
}
|
|
impl Deref for cs0syntax {
|
|
type Target = Parser;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.parser
|
|
}
|
|
}
|
|
impl DerefMut for cs0syntax {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.parser
|
|
}
|
|
}
|