rustlr 0.1.2

LR(1)/LALR(1) parser generator for rust
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

//Parser generated by rustlr

#![allow(unused_variables)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(unused_parens)]
#![allow(unused_mut)]
#![allow(unused_imports)]
#![allow(unused_assignments)]
extern crate rustlr;
use rustlr::{RuntimeParser,RProduction,Stateaction,decode_action};

 /* (i32,i32) defaults to (0,0), used to form two-counter automaton. */

const SYMBOLS:[&'static str;10] = ["A","B","C","AB","S","a","b","c","START","EOF"];

const TABLE:[u64;30] = [30064967682,12885098497,25770000386,17180000257,38654902274,21475033090,65537,281479271940097,281505041809410,281500746842114,281513631744002,281496451874816,562988608126979,844454995361794,844463585296386,844433520459777,1125938561613826,1125929971679234,1125925677105152,1407404948455426,1407396358520834,1407413538390018,1407400653488130,1688888514969602,1688879925559296,1970354902007810,1970350607040514,1970363491942402,2251829878849538,2251838468784130,];

pub fn make_parser() -> RuntimeParser<bool,(i32,i32)>
{
 let mut parser1:RuntimeParser<bool,(i32,i32)> = RuntimeParser::new(9,9);
 let mut rule = RProduction::<bool,(i32,i32)>::new_skeleton("start");
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("S");
 rule.Ruleaction = |parser|{ parser.stack.pop();   let ok:bool=parser.stack.pop().unwrap().value;   let (an,bn)=parser.exstate; println!("counters at end: an {}, bn {}",an,bn); ok && bn==0 };
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("AB");
 rule.Ruleaction = |parser|{ parser.stack.pop();  parser.stack.pop();   let (an,bn)=parser.exstate; if an!=bn {parser.abort("different numbers of a's and b's");} an==bn };
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("A");
 rule.Ruleaction = |parser|{ parser.stack.pop();  parser.stack.pop();   parser.exstate.0+=1; true };
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("A");
 rule.Ruleaction = |parser|{  return <bool>::default();};
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("B");
 rule.Ruleaction = |parser|{ parser.stack.pop();  parser.stack.pop();   parser.exstate.1+=1; true };
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("B");
 rule.Ruleaction = |parser|{  return <bool>::default();};
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("C");
 rule.Ruleaction = |parser|{ parser.stack.pop();  parser.stack.pop();   parser.exstate.1-=1; true };
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("C");
 rule.Ruleaction = |parser|{  return <bool>::default();};
 parser1.Rules.push(rule);
 rule = RProduction::<bool,(i32,i32)>::new_skeleton("START");
 rule.Ruleaction = |parser|{ parser.stack.pop();   return <bool>::default();};
 parser1.Rules.push(rule);
 parser1.Errsym = "";

 for i in 0..30 {
   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

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