lr-parser/parser-test.cpp at master · dbalchev/lr-parser · GitHub

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
#include <cstdio>
#include "parser.hpp"

#define DOT_CHAR 'O'

#if 0
t -> i
t -> t * i
s -> t
s -> s + t
#endif

typedef parser::default_parser::symbol symbol;
typedef parser::default_parser::rule rule;
typedef parser::default_parser::item_set item_set;

void print (const parser::default_parser::rule &rule)
{
    putchar(rule.get_left_hand());
    printf(" -> ");
    for (int i = 0; i < rule.size(); ++i)
        putchar(rule[i]);
    putchar('\n');
}

void print(const parser::default_parser::item &item)
{
    putchar(item.get_left_hand());
    printf(" -> ");
    for (int i = 0; i < item.get_dot_position(); ++i)
        putchar(item.get_rule()[i]);
    putchar(DOT_CHAR);
    for (int i = item.get_dot_position(); i < item.get_rule().size(); ++i)
        putchar(item.get_rule()[i]);
    putchar('\n');
}
void print(const parser::default_parser::item_set &item_set)
{
    puts("<item-set>");
    for (item_set::const_iterator it = item_set.begin(); it != item_set.end(); ++it)
        print(*it);
    puts("</item-set>");
}

struct token
{
    symbol s;
    token()
    {
    }
    const symbol& get_symbol()const
    {
        return s;
    }
    token(const symbol &s)
    {
        this->s = s;
    }
    template<typename ITERATOR>
        token(const rule &r, ITERATOR begin, ITERATOR end)
        {
            s = r.get_left_hand();
            print(r);
        }
};
struct srule
{
    unsigned int left_hand;
    const char * right_hand;
    int precedence;
    parser::ASSOCIATIVITY assoc;
    rule get_rule()
    {
        int sz;
        for (sz = 0; right_hand[sz]; ++sz)
            ;
        return rule(left_hand, right_hand, right_hand + sz, precedence, assoc);
    }
};
int main()
{
    try {
        parser::default_parser p;
        unsigned int symbols[] = {'i', '+', 's', 'e', '*', '$', '(', ')'};
        srule rules[] = {
            {'s', "e$", 0, parser::NOASSOC},
            {'e', "e+e", 1, parser::LEFT_ASSOC},
            {'e', "e*e", 2, parser::LEFT_ASSOC},
            {'e', "(e)", 3, parser::NOASSOC},
            {'e', "i", 2, parser::NOASSOC}};
        const char *input = "i+i*(i+i)*i+i";
        p.symbols.assign(symbols, symbols + 9);
        for (int i = 0; i < 5; ++i) {
            p.rules.push_back(rules[i].get_rule());
        }

#if 0
        parser::default_parser::item_set_list graph = p.generate_states('s');
        for (int i = 0; i < graph.size(); ++i) {
            print(graph[i]);
        }
#endif
        fflush(stdout);
        parser::default_parser::context<token> context(p, 's');
        while(*input)
        {
            context.feed_symbol(*input++);
        }
        context.feed_symbol(token('$'));

    } catch(std::exception &ex) {
        printf("exception: %s\n", ex.what());
    }
    return 0;

}