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

192d191
<      let defaultrtype = format!("_PE_Default({})",&self.Absyntype);
252c251
< 	          let mut newterm = Gsym::new(stokens[i],true);
---
> 	          let newterm = Gsym::new(stokens[i],true);
254d252
<                   newterm.settype(&defaultrtype);
267,276c265
<               if stokens.len()>2 && stokens[2]!="mut" {
< 	         let rtype = format!("_PE_Variant_{}({})",self.Symbols.len(),tokentype.trim());
< 		 newterm.settype(&rtype);
<                }
<                else {
<                  newterm.settype(&defaultrtype);
<                }               
< 
<                newterm.settype(tokentype.trim()); // need comment out!**
<                
---
>                newterm.settype(tokentype.trim());
287,297c276,281
<                if stokens.len()>2 && stokens[2]!="mut" {
< 	         let rtype = format!("_PE_Variant_{}({})",self.Symbols.len(),tokentype.trim());
< 		 newterm.settype(&rtype);
<                }
<                else {
<                  let rtype = format!("_PE_Default({})",&self.Absyntype);
<                  newterm.settype(&defaultrtype);
<                }               
< 
<                newterm.settype(tokentype.trim()); // need to comment out!
< 
---
> //	       if stokens.len()>2 && stokens[2]!="mut" {
> //	         let rtype = format!("PE_Variant_{}({})",self.Symbols.len(),tokentype.trim());
> //		 newterm.settype(&rtype);
>                newterm.settype(tokentype.trim());
> //               }
> //               else {newterm.settype(&self.Absyntype);}
304c288
< 	          let mut newterm = Gsym::new(stokens[i],false);
---
> 	          let newterm = Gsym::new(stokens[i],false);
306,307d289
<                   let rtype = format!("_PE_Default({})",&self.Absyntype);
<                   newterm.settype(&rtype);
764,778d745
< 
< 
< pub fn gen_enum(&self,fd:&mut File) -> Result<(),std::io::Error>
< {
<     let ref absyn = self.Absyntype;
<     let ref lifetime = self.lifetime;
<     let has_lt = lifetime.len()>0 && (absyn.contains(lifetime));
<     let ltopt = if has_lt {format!("<{}>",lifetime)} else {String::from("")};
<     //enum name is Retenumgrammarname, variant is _grammarname_enum_{n}
<     let enumname = format!("RetEnum_{}",&self.name);
<     let symlen = self.Symbols.len();
<     write!(fd,"\n//Enum for return values \nenum {} {{\n",&enumname)?;
<     
<     Ok(())
< }// generate enum from rusttype defs