perplex 0.4.1

A grammar analyzer and LR(k)/GLR parser generator.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

// Copyright (c) 2018 Fabian Schuiki
extern crate perplex;

use std::path::PathBuf;
use std::fs::File;

use perplex::grammar::{self, Grammar, Rule};
use perplex::item_set::ItemSets;
use perplex::machine::StateMachine;
use perplex::backend::{generate_parser, Backend};

fn main() {
    // Build the grammar for grammars (how meta!).
    let mut g = Grammar::new();

    let nt_desc = g.add_nonterminal("desc");
    let nt_item = g.add_nonterminal("item");
    let nt_token_decl = g.add_nonterminal("token_decl");
    let nt_token_name = g.add_nonterminal("token_name");
    let nt_rule_decl = g.add_nonterminal("rule_decl");
    let nt_rule_list = g.add_nonterminal("rule_list");
    let nt_variant = g.add_nonterminal("variant");
    let nt_sequence_or_epsilon = g.add_nonterminal("sequence_or_epsilon");
    let nt_sequence = g.add_nonterminal("sequence");

    let t_ident = g.add_terminal("IDENT");
    let t_code = g.add_terminal("CODE");
    let t_kw_token = g.add_terminal("'token'");
    let t_kw_epsilon = g.add_terminal("'epsilon'");
    let t_kw_end = g.add_terminal("'end'");
    let t_lparen = g.add_terminal("'('");
    let t_rparen = g.add_terminal("')'");
    let t_lbrace = g.add_terminal("'{'");
    let t_rbrace = g.add_terminal("'}'");
    let t_period = g.add_terminal("'.'");
    let t_colon = g.add_terminal("':'");
    let t_comma = g.add_terminal("','");
    let t_semicolon = g.add_terminal("';'");
    let t_pipe = g.add_terminal("'|'");

    // desc : desc item | item | desc ';' | ';' ;
    let r_desc_a = g.add_rule(Rule::new(nt_desc, vec![nt_desc.into(), nt_item.into()]));
    let r_desc_b = g.add_rule(Rule::new(nt_desc, vec![nt_item.into()]));
    let r_desc_c = g.add_rule(Rule::new(nt_desc, vec![nt_desc.into(), t_semicolon.into()]));
    let r_desc_d = g.add_rule(Rule::new(nt_desc, vec![t_semicolon.into()]));

    // item : token_decl | rule_decl ;
    let r_item_a = g.add_rule(Rule::new(nt_item, vec![nt_token_decl.into()]));
    let r_item_b = g.add_rule(Rule::new(nt_item, vec![nt_rule_decl.into()]));

    // token_decl : 'token' token_name '(' CODE ')' ';' ;
    let r_token_decl = g.add_rule(Rule::new(
        nt_token_decl,
        vec![
            t_kw_token.into(),
            nt_token_name.into(),
            t_lparen.into(),
            t_code.into(),
            t_rparen.into(),
            t_semicolon.into(),
        ],
    ));

    // token_name : IDENT | 'end' ;
    let r_token_name_a = g.add_rule(Rule::new(nt_token_name, vec![t_ident.into()]));
    let r_token_name_b = g.add_rule(Rule::new(nt_token_name, vec![t_kw_end.into()]));

    // rule_decl : IDENT '(' CODE ')' '{' rule_list '}' ;
    let r_rule_decl = g.add_rule(Rule::new(
        nt_rule_decl,
        vec![
            t_ident.into(),
            t_lparen.into(),
            t_code.into(),
            t_rparen.into(),
            t_lbrace.into(),
            nt_rule_list.into(),
            t_rbrace.into(),
        ],
    ));

    // rule_list : rule_list variant | variant;
    let r_rule_list_a = g.add_rule(Rule::new(
        nt_rule_list,
        vec![nt_rule_list.into(), nt_variant.into()],
    ));
    let r_rule_list_b = g.add_rule(Rule::new(nt_rule_list, vec![nt_variant.into()]));

    // variant : sequence_or_epsilon '(' CODE ')' ';'
    let r_variant = g.add_rule(Rule::new(
        nt_variant,
        vec![
            nt_sequence_or_epsilon.into(),
            t_lparen.into(),
            t_code.into(),
            t_rparen.into(),
            t_semicolon.into(),
        ],
    ));

    // sequence_or_epsilon : sequence | 'epsilon' ;
    let r_sequence_or_epsilon_a =
        g.add_rule(Rule::new(nt_sequence_or_epsilon, vec![nt_sequence.into()]));
    let r_sequence_or_epsilon_b =
        g.add_rule(Rule::new(nt_sequence_or_epsilon, vec![t_kw_epsilon.into()]));

    // sequence : sequence IDENT | IDENT ;
    let r_sequence_a = g.add_rule(Rule::new(
        nt_sequence,
        vec![nt_sequence.into(), t_ident.into()],
    ));
    let r_sequence_b = g.add_rule(Rule::new(nt_sequence, vec![t_ident.into()]));

    // Compute the item sets for the grammar.
    let is = ItemSets::compute(&g);
    eprintln!("Perplex Grammar Item Sets:");
    eprintln!("{}", is.pretty(&g));

    // Configure the code generation backend.
    let mut backend = Backend::new();

    backend.add_nonterminal(nt_desc, "ast::Desc");
    backend.add_nonterminal(nt_item, "ast::Item");
    backend.add_nonterminal(nt_token_decl, "ast::TokenDecl");
    backend.add_nonterminal(nt_token_name, "ast::TokenName");
    backend.add_nonterminal(nt_rule_decl, "ast::RuleDecl");
    backend.add_nonterminal(nt_rule_list, "Vec<ast::Variant>");
    backend.add_nonterminal(nt_variant, "ast::Variant");
    backend.add_nonterminal(nt_sequence_or_epsilon, "Vec<String>");
    backend.add_nonterminal(nt_sequence, "Vec<String>");

    backend.add_terminal(grammar::END, "None");
    backend.add_terminal(t_ident, "Some(Token::Ident(_))");
    backend.add_terminal(t_code, "Some(Token::Code(_))");
    backend.add_terminal(t_kw_token, "Some(Token::Keyword(Keyword::Token))");
    backend.add_terminal(t_kw_epsilon, "Some(Token::Keyword(Keyword::Epsilon))");
    backend.add_terminal(t_kw_end, "Some(Token::Keyword(Keyword::End))");
    backend.add_terminal(t_lparen, "Some(Token::LParen)");
    backend.add_terminal(t_rparen, "Some(Token::RParen)");
    backend.add_terminal(t_lbrace, "Some(Token::LBrace)");
    backend.add_terminal(t_rbrace, "Some(Token::RBrace)");
    backend.add_terminal(t_period, "Some(Token::Period)");
    backend.add_terminal(t_colon, "Some(Token::Colon)");
    backend.add_terminal(t_comma, "Some(Token::Comma)");
    backend.add_terminal(t_semicolon, "Some(Token::Semicolon)");
    backend.add_terminal(t_pipe, "Some(Token::Pipe)");

    backend.add_reduction_function(r_desc_a, "reduce_desc_a");
    backend.add_reduction_function(r_desc_b, "reduce_desc_b");
    backend.add_reduction_function(r_desc_c, "reduce_desc_c");
    backend.add_reduction_function(r_desc_d, "reduce_desc_d");
    backend.add_reduction_function(r_item_a, "reduce_item_a");
    backend.add_reduction_function(r_item_b, "reduce_item_b");
    backend.add_reduction_function(r_token_decl, "reduce_token_decl");
    backend.add_reduction_function(r_token_name_a, "reduce_token_name_a");
    backend.add_reduction_function(r_token_name_b, "reduce_token_name_b");
    backend.add_reduction_function(r_rule_decl, "reduce_rule_decl");
    backend.add_reduction_function(r_rule_list_a, "reduce_rule_list_a");
    backend.add_reduction_function(r_rule_list_b, "reduce_rule_list_b");
    backend.add_reduction_function(r_variant, "reduce_variant");
    backend.add_reduction_function(r_sequence_or_epsilon_a, "reduce_sequence_or_epsilon_a");
    backend.add_reduction_function(r_sequence_or_epsilon_b, "reduce_sequence_or_epsilon_b");
    backend.add_reduction_function(r_sequence_a, "reduce_sequence_a");
    backend.add_reduction_function(r_sequence_b, "reduce_sequence_b");

    // // Generate the parser code.
    // let sm = StateMachine::try_from(&is).expect("failed to generate state machine");
    // let stdout = std::io::stdout();
    // generate_parser(&mut stdout.lock(), &backend, &sm, &g).expect("failed to generate parser code");

    // Generate the parser code.
    let mut path = PathBuf::from(file!());
    path.pop();
    path.pop();
    path.push("src");
    path.push("parser_states.rs");
    eprintln!("Generating parser code in {:?}", path);
    let sm = StateMachine::try_from(&is).expect("failed to generate state machine");
    generate_parser(&mut File::create(path).unwrap(), &backend, &sm, &g)
        .expect("failed to generate parser code");
}