rustlr 0.3.0

LR/LALR parser generator that can automatically create abstract syntax trees
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//Parser generated by rustlr for grammar nonslr
    
#![allow(unused_variables)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(unused_parens)]
#![allow(unused_mut)]
#![allow(unused_imports)]
#![allow(unused_assignments)]
#![allow(dead_code)]
#![allow(unreachable_patterns)]
#![allow(irrefutable_let_patterns)]
use std::marker::PhantomData;
use std::rc::Rc;
use std::cell::RefCell;
extern crate rustlr;
use rustlr::{Tokenizer,TerminalToken,ZCParser,ZCRProduction,Stateaction,decode_action};
use rustlr::LBox;
use crate::nonslr_ast;
use crate::nonslr_ast::*;

static SYMBOLS:[&'static str;9] = ["_WILDCARD_TOKEN_","S","L","R","Id","Star","Eq","START","EOF"];

static TABLE:[u64;24] = [4295098369,8590196737,21475033088,12885229569,17179934720,281509336645634,281500746711042,562984313159683,844433520459777,844442110066688,844446405165056,844437815492609,1125925677170688,1125934266843138,1407409243357186,1688875630329858,1688884220264450,1970359196844034,1970350606909442,2251816993619968,2251821288718336,2251808404013057,2251812699176961,2533309150134274,];


fn _semaction_rule_0_(parser:&mut ZCParser<RetTypeEnum,()>) -> S {
let mut _item2_ = if let RetTypeEnum::Enumvariant_5(_x_5)=parser.popstack().value { _x_5 } else {<R>::default()}; let mut _item1_ = if let RetTypeEnum::Enumvariant_1(_x_1)=parser.popstack().value { _x_1 } else {<()>::default()}; let mut _item0_ = if let RetTypeEnum::Enumvariant_4(_x_4)=parser.popstack().value { _x_4 } else {<L>::default()};  S::S_0(parser.lbx(0,_item0_),parser.lbx(2,_item2_)) }

fn _semaction_rule_1_(parser:&mut ZCParser<RetTypeEnum,()>) -> S {
let mut _item0_ = if let RetTypeEnum::Enumvariant_5(_x_5)=parser.popstack().value { _x_5 } else {<R>::default()};  S::S_1(parser.lbx(0,_item0_)) }

fn _semaction_rule_2_(parser:&mut ZCParser<RetTypeEnum,()>) -> L {
let mut _item1_ = if let RetTypeEnum::Enumvariant_5(_x_5)=parser.popstack().value { _x_5 } else {<R>::default()}; let mut _item0_ = if let RetTypeEnum::Enumvariant_1(_x_1)=parser.popstack().value { _x_1 } else {<()>::default()};  L::Star_2(parser.lbx(1,_item1_)) }

fn _semaction_rule_3_(parser:&mut ZCParser<RetTypeEnum,()>) -> L {
let mut _item0_ = if let RetTypeEnum::Enumvariant_1(_x_1)=parser.popstack().value { _x_1 } else {<()>::default()};  L::Id }

fn _semaction_rule_4_(parser:&mut ZCParser<RetTypeEnum,()>) -> R {
let mut _item0_ = if let RetTypeEnum::Enumvariant_4(_x_4)=parser.popstack().value { _x_4 } else {<L>::default()};  R {_item0_:parser.lbx(0,_item0_), } }

fn _semaction_rule_5_(parser:&mut ZCParser<RetTypeEnum,()>) -> S {
let mut _item0_ = if let RetTypeEnum::Enumvariant_0(_x_0)=parser.popstack().value { _x_0 } else {<S>::default()}; <S>::default()}

pub fn make_parser() -> ZCParser<RetTypeEnum,()>
{
 let mut parser1:ZCParser<RetTypeEnum,()> = ZCParser::new(6,10);
 let mut rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("start");
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("S");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_0(_semaction_rule_0_(parser)) };
 parser1.Rules.push(rule);
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("S");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_0(_semaction_rule_1_(parser)) };
 parser1.Rules.push(rule);
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("L");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_4(_semaction_rule_2_(parser)) };
 parser1.Rules.push(rule);
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("L");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_4(_semaction_rule_3_(parser)) };
 parser1.Rules.push(rule);
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("R");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_5(_semaction_rule_4_(parser)) };
 parser1.Rules.push(rule);
 rule = ZCRProduction::<RetTypeEnum,()>::new_skeleton("START");
 rule.Ruleaction = |parser|{  RetTypeEnum::Enumvariant_0(_semaction_rule_5_(parser)) };
 parser1.Rules.push(rule);
 parser1.Errsym = "";

 for i in 0..24 {
   let symi = ((TABLE[i] & 0x0000ffff00000000) >> 32) as usize;
   let sti = ((TABLE[i] & 0xffff000000000000) >> 48) as usize;
   parser1.RSM[sti].insert(SYMBOLS[symi],decode_action(TABLE[i]));
 }

 for s in SYMBOLS { parser1.Symset.insert(s); }

 load_extras(&mut parser1);
 return parser1;
} //make_parser

pub fn parse_with<'t>(parser:&mut ZCParser<RetTypeEnum,()>, lexer:&mut nonslrlexer<'t>) -> Result<S,S>
{
  lexer.shared_state = Rc::clone(&parser.shared_state);
  if let RetTypeEnum::Enumvariant_0(_xres_) = parser.parse(lexer) {
     if !parser.error_occurred() {Ok(_xres_)} else {Err(_xres_)}
  } else { Err(<S>::default())}
}//parse_with public function

pub fn parse_train_with<'t>(parser:&mut ZCParser<RetTypeEnum,()>, lexer:&mut nonslrlexer<'t>, parserpath:&str) -> Result<S,S>
{
  lexer.shared_state = Rc::clone(&parser.shared_state);
  if let RetTypeEnum::Enumvariant_0(_xres_) = parser.parse_train(lexer,parserpath) {
     if !parser.error_occurred() {Ok(_xres_)} else {Err(_xres_)}
  } else { Err(<S>::default())}
}//parse_train_with public function

//Enum for return values 
pub enum RetTypeEnum {
  Enumvariant_2((usize,usize)),
  Enumvariant_0(S),
  Enumvariant_4(L),
  Enumvariant_1(()),
  Enumvariant_5(R),
}
impl Default for RetTypeEnum { fn default()->Self {RetTypeEnum::Enumvariant_0(<S>::default())} }

fn load_extras(parser:&mut ZCParser<RetTypeEnum,()>)
{
}//end of load_extras: don't change this line as it affects augmentation