-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathutils.py
320 lines (293 loc) · 11.9 KB
/
utils.py
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
#!/usr/bin/python3
'''Add stuffs for checkers'''
if True:
AST_NODE_TYPE_NULL = 0x0
AST_NODE_TYPE_METHOD = 0x1
AST_NODE_TYPE_PARAM = 0x2
AST_NODE_TYPE_BLOCK = 0x3
AST_NODE_TYPE_LOCAL = 0x4
AST_NODE_TYPE_IDENT = 0x5
AST_NODE_TYPE_FIELD_IDENT = 0x6
AST_NODE_TYPE_CONTROL = 0x7
AST_NODE_TYPE_LITERAL = 0x8
AST_NODE_TYPE_JUMP_TARGET = 0x9
AST_NODE_TYPE_RETURN = 0xa
AST_NODE_TYPE_METHOD_RETURN = 0xb
AST_NODE_TYPE_UNKNOWN = 0xc
AST_NODE_TYPE_OP_ASSIGN = 0x100
AST_NODE_TYPE_OP_ADROF = 0x101
AST_NODE_TYPE_OP_FIELDACCESS = 0x102
AST_NODE_TYPE_OP_INDFIELDACCESS = 0x103
AST_NODE_TYPE_OP_LOGICALNOT = 0x104
AST_NODE_TYPE_OP_LOGICALAND = 0x105
AST_NODE_TYPE_OP_LOGICALOR = 0x106
AST_NODE_TYPE_OP_INDINDEXACCESS = 0x107
AST_NODE_TYPE_OP_EQUAL = 0x108
AST_NODE_TYPE_OP_NOTEQUAL = 0x109
AST_NODE_TYPE_OP_ARRAYINIT = 0x10a
AST_NODE_TYPE_OP_SUBTRACT = 0x10b
AST_NODE_TYPE_OP_LESSTHAN = 0x10c
AST_NODE_TYPE_OP_SIZEOF = 0x10d
AST_NODE_TYPE_OP_IND = 0x10e
AST_NODE_TYPE_OP_NOT = 0x10f
AST_NODE_TYPE_OP_AND = 0x110
AST_NODE_TYPE_OP_GREATERTHAN = 0x111
AST_NODE_TYPE_OP_GREATEREQTHAN = 0x112
AST_NODE_TYPE_OP_COND = 0x113
AST_NODE_TYPE_OP_MINUS = 0x114
AST_NODE_TYPE_OP_MULTI = 0x115
AST_NODE_TYPE_OP_ASSGMINUS = 0x116
AST_NODE_TYPE_OP_ASSGOR = 0x117
AST_NODE_TYPE_OP_POSTDEC = 0x118
AST_NODE_TYPE_OP_POSTINC = 0x119
AST_NODE_TYPE_OP_ARITHSHIFTR = 0x11a
AST_NODE_TYPE_OP_CAST = 0x11b
AST_NODE_TYPE_REAL_METHOD = 0x1000
def get_type(type_str):
if type_str == 'METHOD': #1
return AST_NODE_TYPE_METHOD
elif type_str == 'PARAM': #2
return AST_NODE_TYPE_PARAM
elif type_str == 'BLOCK': #3
return AST_NODE_TYPE_BLOCK
elif type_str == 'LOCAL': #4
return AST_NODE_TYPE_LOCAL
elif type_str == 'IDENTIFIER': #5
return AST_NODE_TYPE_IDENT
elif type_str == 'FIELD_IDENTIFIER': #6
return AST_NODE_TYPE_FIELD_IDENT
elif type_str == 'CONTROL_STRUCTURE': #7
return AST_NODE_TYPE_CONTROL
elif type_str == 'LITERAL': #8
return AST_NODE_TYPE_LITERAL
elif type_str == 'JUMP_TARGET': #9
return AST_NODE_TYPE_JUMP_TARGET
elif type_str == 'RETURN': #A
return AST_NODE_TYPE_RETURN
elif type_str == 'METHOD_RETURN': #B
return AST_NODE_TYPE_METHOD_RETURN
elif type_str == 'UNKNOWN': #C
return AST_NODE_TYPE_UNKNOWN
elif type_str == '<operator>.assignment':
return AST_NODE_TYPE_OP_ASSIGN
elif type_str == '<operator>.addressOf':
return AST_NODE_TYPE_OP_ADROF
elif type_str == '<operator>.fieldAccess':
return AST_NODE_TYPE_OP_FIELDACCESS
elif type_str == '<operator>.indirectFieldAccess':
return AST_NODE_TYPE_OP_INDFIELDACCESS
elif type_str == '<operator>.logicalNot':
return AST_NODE_TYPE_OP_LOGICALNOT
elif type_str == '<operator>.logicalAnd':
return AST_NODE_TYPE_OP_LOGICALAND
elif type_str == '<operator>.logicalOr':
return AST_NODE_TYPE_OP_LOGICALOR
elif type_str == '<operator>.indirectIndexAccess':
return AST_NODE_TYPE_OP_INDINDEXACCESS
elif type_str == '<operator>.equals':
return AST_NODE_TYPE_OP_EQUAL
elif type_str == '<operator>.notEquals':
return AST_NODE_TYPE_OP_NOTEQUAL
elif type_str == '<operator>.arrayInitializer':
return AST_NODE_TYPE_OP_ARRAYINIT
elif type_str == '<operator>.subtraction':
return AST_NODE_TYPE_OP_SUBTRACT
elif type_str == '<operator>.lessThan':
return AST_NODE_TYPE_OP_LESSTHAN
elif type_str == '<operator>.sizeOf':
return AST_NODE_TYPE_OP_SIZEOF
elif type_str == '<operator>.indirection':
return AST_NODE_TYPE_OP_IND
elif type_str == '<operator>.not':
return AST_NODE_TYPE_OP_NOT
elif type_str == '<operator>.and':
return AST_NODE_TYPE_OP_AND
elif type_str == '<operator>.greaterThan':
return AST_NODE_TYPE_OP_GREATERTHAN
elif type_str == '<operator>.greaterEqualsThan':
return AST_NODE_TYPE_OP_GREATEREQTHAN
elif type_str == '<operator>.conditional':
return AST_NODE_TYPE_OP_COND
elif type_str == '<operator>.minus':
return AST_NODE_TYPE_OP_MINUS
elif type_str == '<operator>.multiplication':
return AST_NODE_TYPE_OP_MULTI
elif type_str == '<operator>.assignmentMinus':
return AST_NODE_TYPE_OP_ASSGMINUS
elif type_str == '<operators>.assignmentOr':
return AST_NODE_TYPE_OP_ASSGOR
elif type_str == '<operator>.postDecrement':
return AST_NODE_TYPE_OP_POSTDEC
elif type_str == '<operator>.postIncrement':
return AST_NODE_TYPE_OP_POSTINC
elif type_str == '<operator>.arithmeticShiftRight':
return AST_NODE_TYPE_OP_ARITHSHIFTR
elif type_str == '<operator>.cast':
return AST_NODE_TYPE_OP_CAST
else:
return AST_NODE_TYPE_REAL_METHOD
def get_type_str(t):
if t == AST_NODE_TYPE_METHOD: #1
return 'METHOD'
elif t == AST_NODE_TYPE_PARAM: #2
return 'PARAM'
elif t == AST_NODE_TYPE_BLOCK: #3
return 'BLOCK'
elif t == AST_NODE_TYPE_LOCAL: #4
return 'LOCAL'
elif t == AST_NODE_TYPE_IDENT: #5
return 'IDENTIFIER'
elif t == AST_NODE_TYPE_FIELD_IDENT: #6
return 'FIELD_IDENTIFIER'
elif t == AST_NODE_TYPE_CONTROL: #7
return 'CONTROL_STRUCTURE'
elif t == AST_NODE_TYPE_LITERAL: #8
return 'LITERAL'
elif t == AST_NODE_TYPE_JUMP_TARGET: #9
return 'JUMP_TARGET'
elif t == AST_NODE_TYPE_RETURN: #A
return 'RETURN'
elif t == AST_NODE_TYPE_METHOD_RETURN: #B
return 'METHOD_RETURN'
elif t == AST_NODE_TYPE_UNKNOWN: #C
return 'UNKNOWN'
elif t == AST_NODE_TYPE_OP_ASSIGN:
return '.assignment'
elif t == AST_NODE_TYPE_OP_ADROF:
return '.addressOf'
elif t == AST_NODE_TYPE_OP_FIELDACCESS:
return '.fieldAccess'
elif t == AST_NODE_TYPE_OP_INDFIELDACCESS:
return '.indirectFieldAccess'
elif t == AST_NODE_TYPE_OP_LOGICALNOT:
return '.logicalNot'
elif t == AST_NODE_TYPE_OP_LOGICALAND:
return '.logicalAnd'
elif t == AST_NODE_TYPE_OP_LOGICALOR:
return '.logicalOr'
elif t == AST_NODE_TYPE_OP_INDINDEXACCESS:
return '.indirectIndexAccess'
elif t == AST_NODE_TYPE_OP_EQUAL:
return '.equals'
elif t == AST_NODE_TYPE_OP_NOTEQUAL:
return '.notEquals'
elif t == AST_NODE_TYPE_OP_ARRAYINIT:
return '.arrayInitializer'
elif t == AST_NODE_TYPE_OP_SUBTRACT:
return '.subtraction'
elif t == AST_NODE_TYPE_OP_LESSTHAN:
return '.lessThan'
elif t == AST_NODE_TYPE_OP_SIZEOF:
return '.sizeOf'
elif t == AST_NODE_TYPE_OP_IND:
return '.indirection'
elif t == AST_NODE_TYPE_OP_NOT:
return '.not'
elif t == AST_NODE_TYPE_OP_AND:
return '.and'
elif t == AST_NODE_TYPE_OP_GREATERTHAN:
return '.greaterThan'
elif t == AST_NODE_TYPE_OP_GREATEREQTHAN:
return '.greaterEqualsThan'
elif t == AST_NODE_TYPE_OP_COND:
return '.conditional'
elif t == AST_NODE_TYPE_OP_MINUS:
return '.minus'
elif t == AST_NODE_TYPE_OP_MULTI:
return '.multiplication'
elif t == AST_NODE_TYPE_OP_ASSGMINUS:
return '.assignmentMinus'
elif t == AST_NODE_TYPE_OP_ASSGOR:
return '.assignmentOr'
elif t == AST_NODE_TYPE_OP_POSTDEC:
return '.postDecrement'
elif t == AST_NODE_TYPE_OP_POSTINC:
return '.postIncrement'
elif t == AST_NODE_TYPE_OP_ARITHSHIFTR:
return '.arithmeticShiftRight'
elif t == AST_NODE_TYPE_OP_CAST:
return '.cast'
else:
return 'real_method'
class AST_Node:
num = -1
type = AST_NODE_TYPE_NULL
type_str= ''
src = ''
dot_src = ''
line = -1
def __init__(self, mytype=AST_NODE_TYPE_NULL):
self.type = mytype
self.nb = []
self.parent = []
self.var_str = ''
class AST_Graph:
name = 'unknown'
def __init__(self, name):
self.name = name
self.node_set = {}
self.edge_set = {}
def set_name(self, name):
self.name = name
def get_name(self):
return self.name
def build_ast_from_str(strs):
ast_g = ''
is_end = False
last_line = -1
for l in strs.split('\n'):
if l=='': break
#print(l)
if is_end==True:
print('NOT ONE {, ERROR!!!')
exit(-1)
if l.find('label = <>')!=-1:
continue
if l[:7]=='digraph': #graph
m = l.split(' ')[1][1:-1].strip()
ast_g = AST_Graph(l[l.find('\"')+1:l.rfind('\"')])
#print 'GRAPH: %s'%(ast_g.get_name())
elif l.find('->')==-1 and l[0]!='}': # node
is_macro_wrapper_function = 0
if l.find('SUB')==-1: # ANY real-method should have LINE-NUMBER!
if l.find('BLOCK')!=-1 or l.find('label')!=-1 or l.find('IDENTIFIER')!=-1:
is_macro_wrapper_function=1
else:
print(l)
print('No Line Number?')
exit(-1)
#return ''
node = AST_Node()
node.num = int(l.split(' ')[0][1:-1])
attributes = l.split('<')[1][1:-1].strip()
if is_macro_wrapper_function==1:
node.line = 0
else:
node.line = int(l.split('>')[1].split('<')[0].strip())
last_line = node.line
node.type_str = attributes.split(',')[0].strip()
node.type = get_type(node.type_str)
if node.type == AST_NODE_TYPE_IDENT:
node.var_str = attributes.split(',')[1].strip()
node.dot_src = l
ast_g.node_set[node.num] = node
elif l[0]=='}':
is_end=True
#print 'Done'
elif l.find('->')!=-1:
start = int(l.split('->')[0].strip()[1:-1])
end = int(l.split('->')[1].strip()[1:-1])
if not ( start in ast_g.node_set.keys()):
print('Start Node not in Graph!')
exit(-1)
if not ( end in ast_g.node_set.keys()):
print('End Node not in Graph!')
exit(-1)
ast_g.edge_set[(start, end)] = (ast_g.node_set[start], ast_g.node_set[end])
ast_g.node_set[start].nb.append(ast_g.node_set[end])
ast_g.node_set[end].parent.append(ast_g.node_set[start])
else:
print(l)
print('ERROR!')
exit(-1)
return ast_g