misp/parser.py at master · eignnx/misp · 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
from sly import Parser
from lexer import Lexer
import AST

class Parser(Parser):
    tokens = Lexer.tokens

#    @_("expression")
#    def program(self, p):
#        return p.expression

    @_("expressions")
    def program(self, p):
        return p.expressions

    @_("LPAREN expressions RPAREN")
    def paren_expression(self, p):
        return AST.SExpression(*p.expressions)

    @_("LPAREN RPAREN")
    def paren_expression(self, p):
        return AST.SExpression()

    @_("expression LBRACK RBRACK")
    def brack_expression(self, p):
        return AST.SExpression(p.expression)

    @_("expression LBRACK expressions RBRACK",
       "LBRACK expressions PIPE expression RBRACK")
    def brack_expression(self, p):
        return AST.SExpression(p.expression, *p.expressions)

    @_("LBRACE expressions RBRACE")
    def brace_expression(self, p):
        return AST.SExpression(AST.Symbol("List"), *p.expressions)

    @_("LBRACE RBRACE")
    def brace_expression(self, p):
        return AST.SExpression(AST.Symbol("List"))

    @_("QUOTE expression")
    def quoted_expression(self, p):
        return AST.SExpression(AST.Symbol("Quote"), p.expression)

    @_("QUASIQUOTE expression")
    def quoted_expression(self, p):
        return AST.SExpression(AST.Symbol("Quasiquote"), p.expression)

    @_("UNQUOTE expression")
    def quoted_expression(self, p):
        return AST.SExpression(AST.Symbol("Unquote"), p.expression)

    @_("expressions expression")
    def expressions(self, p):
        return p.expressions + [p.expression]

    @_("expression")
    def expressions(self, p):
        return [p.expression]

    @_("NUM")
    def expression(self, p):
        return AST.Number(p.NUM)

    @_("NAME")
    def expression(self, p):
        return AST.Symbol(p.NAME)

    @_("STR")
    def expression(self, p):
        return AST.String(p.STR)

    @_("KEYWORD")
    def expression(self, p):
        return AST.Keyword(p.KEYWORD)

    @_("brack_expression")
    def expression(self, p):
        return p.brack_expression

    @_("paren_expression")
    def expression(self, p):
        return p.paren_expression

    @_("brace_expression")
    def expression(self, p):
        return p.brace_expression

    @_("quoted_expression")
    def expression(self, p):
        return p.quoted_expression

    precedence = [
        ("right", QUOTE),
        ("right", PIPE),
        ("left", LBRACK),
    ]

if __name__ == "__main__":
    lexer = Lexer()
    parser = Parser()

    def parse(txt):
        return parser.parse(lexer.tokenize(txt))