-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathprojet2.py
268 lines (206 loc) · 9.74 KB
/
projet2.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
import sys
from constantes import *
import h5py
import pandas as pd
import numpy as np
import logging
def Appliquer(auto, char):
""" Applique une chaine a un automate et renvoie le dernier etat acceptant (ou -1 s'il n'y en a pas) """
etat = 0
i = 0
final = -1
while i < len(char) and etat != -1:
# ~ print char[i], etat, auto.delta[etat][ord(char[i])]
#print("index: ", i)
#print("Etat: ", etat)
#print("char: ", char[i])
#print("ord(char[i])", ord(char[i]))
try:
etat = auto.delta[etat][ord(char[i])]
if etat in auto.F:
final = i
i += 1
except:
final = i
break
return final
def appliquerAutomates(chaine):
""" Permet d'appliquer la chaine sur tous les automates """
listeEtatsFinaux = [Appliquer(AutNum, chaine), Appliquer(AutCar, chaine), Appliquer(AutSymb, chaine),
Appliquer(AutCl, chaine), Appliquer(AutId, chaine)]
# On cherche maintenant le max dans cette liste
max = listeEtatsFinaux[0]
indiceDuMax = 0
for i in range(1, len(listeEtatsFinaux)):
if listeEtatsFinaux[i] > max:
max = listeEtatsFinaux[i]
indiceDuMax = i
return listeEtatsFinaux[indiceDuMax], typeUnLex[
indiceDuMax] # On retourne la plus graned valeur que retourne Appliquer pour les automates, et le type de l'automates qui a cette plus grande valeur.
def AnLex(listProg):
global i
retraitCourant = 0
lexUnits = []
i = 0
j = 0
while j < len(listProg): # On parcourt le programme ligne apres ligne
ligne = listProg[j]
i=0
newRetrait = 0
# On compte le retrait
while i < len(ligne) and ligne[i] == '\t':
if ligne[i] == '\t':
newRetrait += 1
i += 1
if i < len(ligne) and not detecteComments(listProg, j,i): # Si le retrait n'est pas suivi d'un commentaire ou d'un retour a la ligne
if newRetrait - retraitCourant <= 1: # Si on a moins de deux debuts de procedures, c'est bon.
listeLex = debut_fin_procedure(newRetrait - retraitCourant, lexUnits)
retraitCourant = newRetrait
# Ici, on s'est occupe du retrait, donc on peut passer a la suite de la ligne.
while i < len(ligne):
if not detecteComments(listProg, j, i) and not detecteSeparateur(listProg, j, i):
(positionTmp, type) = appliquerAutomates(ligne[i:])
if positionTmp == -1: # Si aucun automate ne reconnait la chaine :
return j, i, MotInvalideError, lexUnits
lex = UnLex(type, ligne[i:i + positionTmp + 1])
# print("On trouve ("+lex.label+", "+lex.type+") dans :", ligne[i:])
i += positionTmp
lexUnits += [lex]
else:
if ligne[i] == '#':
break
elif not detecteSeparateur(listProg, j, i): # Si on a detecte une chaine multilignes :
if cherch3Quotes(listProg, j, i + 3) == False: # Si cette chaine n'est pas fermee.
return j, i, ChaineMultiligneError, lexUnits
else: # On va ajouter la chaine multilignes a la liste des unites lexicales.
(jprime, iprime) = cherch3Quotes(listProg, j, i + 3)
chaine = "\""
i += 3
while j < jprime:
chaine += listProg[j][i:] + "\\n"
i = 0
j += 1
chaine += listProg[j][i:iprime] + "\""
lexUnits += [UnLex('Car', chaine)]
print("On trouve (" + chaine + ", Car). (Chaine multilignes)")
(j, i) = (jprime, iprime)
ligne = listProg[j]
i += 2
i += 1
else: # Si on detecte deux debuts de procedures consecutives, on s'arrete car c'est impossible.
return j, i, IndentationError, lexUnits
else:
if i < len(ligne) and ligne[
i] != '#': # Si on rencontre un commentaire multiligne en debut de ligne ou apres un retrait.
if cherch3Quotes(listProg, j,
i + 3) == False: # Si on ouvre un commentaire multiligne sans le fermer plus tard dans le code :
return j, i, ChaineMultiligneError, lexUnits
else: # Sinon on va a l'endroit ou ce commentaire est ferme.
(j, i) = cherch3Quotes(listProg, j, i + 3)
lexUnits += [UnLex('Symb', '\n')]
j += 1
listeLex = debut_fin_procedure(-retraitCourant, lexUnits)
return j, i, True, lexUnits
def debut_fin_procedure(difference, listeLex):
""" Recoit la difference entre le retraitCourant et le retrait lu, et ecrit les debuts ou fin de procedure en consequences """
if difference == 1:
lex = UnLex('Pr', '${')
listeLex += [lex]
elif difference < 0:
i = difference
while i < 0:
lex = UnLex('Pr', '}$')
listeLex += [lex]
i += 1
return listeLex
def detecteComments(liste, j, i):
""" Retourne True si le caractere courant est un commentaire """
return liste[j][i] == '#' or (
i < len(liste[j]) - 2 and liste[j][i] == "\"" and liste[j][i + 1] == "\"" and liste[j][i + 2] == "\"")
def detecteSeparateur(liste, j, i):
""" Retourne True si le caractere courant est une tabulation ou un espace """
return liste[j][i] in [' ', '\t']
def cherch3Quotes(liste, j, i):
""" Prend une position dans le code python a analyser et renvoie la position du prochain caractere : \""" """
nbGuillemets = 0 # Sert a compter les guillemets doubles consecutifs.
while j < len(liste):
while i < len(liste[j]) - 2:
if liste[j][i] == "\"" and liste[j][i + 1] == "\"" and liste[j][i + 2] == "\"":
return (j, i) # On retourne la position du premier guillemet du groupe de 3
i += 1
i = 0
j += 1
return False
def diviseLignes(prog):
""" Divise une chaine de caracteres par ligne, retourne un tableau ou chaque element est une ligne de prog """
liste = []
ligne = ""
i = 0
while i < len(prog):
if prog[i] == '\n': # Si on rencontre un saut de ligne.
# if ligne != "": # Et si cette ligne precedant le saut de lignes n'etait pas vide, on l'ajoute.
liste += [ligne]
ligne = ""
else: # Si on atteit pas un saut de ligne, on continue a lire
ligne += prog[i]
i += 1
if ligne != "":
liste += [ligne]
return liste
def main_func(inF):
output = ""
# On ouvre les fichiers en arguments.
try:
outF = open('out', "w+")
except IOError:
print(
"\nVerifiez que vous avez bien les droits d'ecritures dans le dossier et que le fichier en entre existe bien.\n")
# print("Initialisation des automates en cours ...")
# temps = time.clock()
# print("Automates pret en " + str(time.clock() - temps) + " secondes !")
# t = time.clock()
listProg = diviseLignes(inF) # Liste contenant le programme divise par lignes.
numLigne, numColonnes, etat, lexique = AnLex(listProg)
# print("\nAnalyse finie en " + str(time.clock() - t) + " secondes.")
# On regarde si l'execution de l'analyseur c'est bien passee.
if etat == True:
print("Tout c'est bien passe.")
for i in lexique:
if i.label != '\n':
output = output + "(" + i.label + ", " + i.type + ") "
outF.write("(" + i.label + ", " + i.type + ") ")
else:
outF.write(
"(\\n, " + i.type + ") ") # Pour afficher \n dans un fichier, il faut lui demander d'ecrire \\n sinon ca ne marche pas.
output = output + "(\\n, " + i.type + ") "
if i.label in ['\n', '${',
'}$']: # Si on detecte un retour a la ligne ou un debut/fin de procedure, on fais un retour a la ligne.
outF.write("\n")
output = output + "\n"
else:
print("")
# print("\n\nErreur a la ligne " + str(numLigne + 1) + ", caractere", str(numColonnes + 1) + ".")
# print(Dictionnaire_Erreurs[etat], "\n")
# print(listProg[numLigne])
# print(" " * numColonnes + "^")
return output
def convert_pickle(dataset):
data = h5py.File("VDISC_" + dataset + ".hdf5", 'r')
item_list = list()
mydf = pd.DataFrame()
for x in range(len(data['functionSource'])):
item = main_func(data['functionSource'][x])
item_list.insert(x,item)
print(str(x))
mydf['functionSource'] = item_list
mydf['CWE-119'] = data["CWE-119"]
mydf['CWE-120'] = data["CWE-120"]
mydf['CWE-469'] = data["CWE-469"]
mydf['CWE-476'] = data["CWE-476"]
mydf['CWE-other'] = data["CWE-other"]
#mydf.rename(columns={0: 'functionSource'}, inplace=True)
mydf.to_pickle("VDISC_" + dataset + ".pickle")
if __name__ == "__main__":
convert_pickle('test')
# convert_pickle('validate')
# convert_pickle('train')