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
|
#!/usr/bin/python3 -tt
# Copyright 2012 Jussi Pakkanen
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ply.lex as lex
import ply.yacc as yacc
tokens = ['LPAREN',
'RPAREN',
'LBRACKET',
'RBRACKET',
'LBRACE',
'RBRACE',
'ATOM',
'COMMENT',
'EQUALS',
'COMMA',
'DOT',
'STRING',
'EOL_CONTINUE',
'EOL',
]
t_EQUALS = '='
t_LPAREN = '\('
t_RPAREN = '\)'
t_LBRACKET = '\['
t_RBRACKET = '\]'
t_LBRACE = '\{'
t_RBRACE = '\}'
t_ATOM = '[a-zA-Z][_0-9a-zA-Z]*'
t_COMMENT = '\#[^\n]*'
t_COMMA = ','
t_DOT = '\.'
t_STRING = "'[^']*'"
t_ignore = ' \t'
def t_EOL(t):
r'\n'
t.lexer.lineno += 1
return t
def t_EOL_CONTINUE(t):
r'\\[ \t]*\n'
t.lexer.lineno += 1
def t_error(t):
print("Illegal character '%s'" % t.value[0])
t.lexer.skip(1)
# Yacc part
def p_codeblock(t):
'codeblock : statement EOL codeblock'
print('Codeblock')
pass
def p_codeblock_last(t):
'codeblock : statement EOL'
print('Single line')
pass
#def p_codeblock_empty(t):
# 'codeblock :'
# pass
def p_expression_atom(t):
'expression : ATOM'
print('Atom: ' + t[1])
t[0] = t[1]
def p_expression_string(t):
'expression : STRING'
print('String: ' + t[1])
t[0] = t[1]
def p_statement_assign(t):
'statement : expression EQUALS statement'
pass
def p_statement_func_call(t):
'statement : expression LPAREN args RPAREN'
print('Function call: %s. Args: %s' % (str(t[1]), str(t[3]))) # t[1])
def p_statement_method_call(t):
'statement : expression DOT expression LPAREN args RPAREN'
print('Method call: %s %s. Args: %s' % (str(t[1]), str(t[3]), str(t[5])))
def p_statement_expression(t):
'statement : expression'
#print('s-e: ' + t[1])
t[0] = t[1]
def p_args_multiple(t):
'args : statement COMMA args'
t[0] = [t[1]] + t[3]
def p_args_single(t):
'args : statement'
t[0] = [t[1]]
def p_args_none(t):
'args :'
pass
def p_error(t):
print('Parser errored out at: ' + t.value)
def test_lexer():
s = """hello = (something) # this = (that)
two = ['file1', 'file2']
function(h) { stuff }
obj.method(lll, \\
'string')
"""
lexer = lex.lex()
lexer.input(s)
while True:
tok = lexer.token()
if not tok:
break
print(tok)
def test_parser():
code = """func_call('something', 'or else')
objectname.methodname(abc)
"""
lexer = lex.lex()
parser = yacc.yacc()
result = parser.parse(code)
print(result)
if __name__ == '__main__':
#test_lexer()
test_parser()
|
