def regex(self):
text = self.lineReconnaisance.text()
if (text):
nom, ok = QtWidgets.QInputDialog.getText(self.window,
'Nouvel Automate',
'Entrez le nom')
if ok:
result = ExpressionReguliere(text).convertir_en_afn()
result.definir_nom(nom or text)
self.list[nom or text] = Automate.a_partir_de(result)
self.automate.copie_automate(Automate.a_partir_de(result))
def newDialog(self):
text, ok = QtWidgets.QInputDialog.getText(self.window,
'Nouvel Automate',
'Entrez le nom')
if ok:
a = Automate(Alphabet([]), [], None, [], [])
a.definir_nom(text)
if text in self.liste_automate:
a.definir_nom(text + '(1)')
self.liste_automate[text + '(1)'] = Automate.a_partir_de(a)
else:
self.liste_automate[text] = Automate.a_partir_de(a)
self.creation.ui.createBtn.setState()
self.automate.copie_automate(a)
def showUnionDialog(self):
if not self.liste_automate or len(self.liste_automate) < 2:
return
item, ok = QtWidgets.QInputDialog.getItem(
self.window, f"Faire l'union de {self.automate.nom} avec",
"Liste des automates", self.liste_automate, 0, False)
if ok and item:
print(f"item {item}")
print(type(self.liste_automate[item]))
resultat = self.automate.union_automate(
Automate.a_partir_de(self.liste_automate[item]))
resultat.definir_nom(self.automate.nom + ' U ' +
self.liste_automate[item].nom)
print(
f'parents {resultat.parents} Nom {[a.nom for a in resultat.parents]}'
)
self.liste_automate[resultat.nom] = Automate.a_partir_de(resultat)
self.automate.copie_automate(Automate.a_partir_de(resultat))
self.creation.ui.createBtn.setState()
def convertir_en_afn(self):
parenthese = False
expression_entre__parenthese = str()
symbole_vers_automate = dict()
expression_traite = list()
index_suivant = 0;
longeur_expression = len(self.expression)
sauter_le_prochain_symbole = False
faire_loperation_sur_la_dernier_expression = False
for symbole in self.expression:
print(symbole)
index_suivant += 1
print(f"index suivant {index_suivant} total {longeur_expression}")
if symbole == ')':
if parenthese:
parenthese = False
automate_correspondant = ExpressionReguliere(expression_entre__parenthese).convertir_en_afn()
symbole_vers_automate[f'P{index_suivant - 1}'] = automate_correspondant
expression_traite.append(f'P{index_suivant - 1}')
faire_loperation_sur_la_dernier_expression = True
expression_entre__parenthese=str()
else:
raise ValueError(f'Parenthese fermante pas approprie au symbole {index_suivant}')
if parenthese:
expression_entre__parenthese += symbole
elif symbole == '(':
parenthese = True
continue
#TODO FAIRE CE CAS
pass
else:
if symbole in ['*', '|', '.', '+']:
if index_suivant == 1:
raise ValueError('Une Expression ne peux pas commencer par un operateur')
else:
if symbole == '.':
expression_traite.append('.')
elif symbole in ['|', '+']:
expression_traite.append('+')
continue
if sauter_le_prochain_symbole:
sauter_le_prochain_symbole = False
continue
if index_suivant <= longeur_expression:
try:
symbole_suivant = self.expression[index_suivant]
except:
symbole_suivant = None
operation_de_concatenation = True
operation_de_addition = False
operation_de_kleen = False
if symbole_suivant == '*':
operation_de_kleen = True
elif symbole_suivant in ['|','+']:
operation_de_addition = True
if operation_de_kleen:
if faire_loperation_sur_la_dernier_expression:
automate_correspondant = GenerateurAutomate.faire_kleen(symbole_vers_automate[expression_traite[-1]])
symbole_vers_automate[expression_traite[-1]] = automate_correspondant
faire_loperation_sur_la_dernier_expression = False
else:
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
automate_correspondant = GenerateurAutomate.faire_kleen(automate_correspondant)
symbole_vers_automate[f'{symbole}{index_suivant-1}'] = automate_correspondant
expression_traite.append(f'{symbole}{index_suivant-1}')
expression_traite.append('.')
print('Kleen a fait')
print(expression_traite)
elif operation_de_addition:
if faire_loperation_sur_la_dernier_expression:
expression_traite.append('+')
faire_loperation_sur_la_dernier_expression = False
continue
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
symbole_vers_automate[f'{symbole}{index_suivant - 1}'] = automate_correspondant
#automate_correspondant.visualiser()
expression_traite.append(f'{symbole}{index_suivant - 1}')
expression_traite.append('+')
print('addition a fait')
print(expression_traite)
else:
if faire_loperation_sur_la_dernier_expression:
expression_traite.append('.')
faire_loperation_sur_la_dernier_expression = False
continue
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
symbole_vers_automate[f'{symbole}{index_suivant - 1}'] = automate_correspondant
expression_traite.append(f'{symbole}{index_suivant - 1}')
expression_traite.append('.')
print('Concat a fais')
print(expression_traite)
taken = False
addition = False
concat = False
dernier_expression = None
counter = -1
expression_traite_normal = []
exp_precedent = None
for expression in expression_traite:
if expression != exp_precedent:
expression_traite_normal.append(expression)
exp_precedent = expression
#reduction des plus
automate_precedent =None
print(f"Expression normal = {expression_traite_normal}")
automata_traite = []
dois_additioner = False
for expression in expression_traite_normal:
if expression == '+':
dois_additioner = True
continue
if expression == '.':
continue
elif dois_additioner:
automata_traite[-1] = GenerateurAutomate.faire_union(automata_traite[-1], symbole_vers_automate[expression])
dois_additioner = False
continue
else:
automata_traite.append(Automate.a_partir_de(symbole_vers_automate[expression]))
#Faire la concat
taken = False
for automate in automata_traite:
if not taken:
resultat = Automate.a_partir_de(automate)
taken = True
else:
resultat = GenerateurAutomate.faire_la_concatenation(Automate.a_partir_de(resultat), automate)
return resultat
print(f"Expression normal = {expression_traite_normal}")
for expression in expression_traite_normal:
counter += 1
#symbole_vers_automate[expression].visualiser()
if expression == '.':
concat = True
elif expression == '+':
addition = True
concat = False
elif not taken:
resultat = symbole_vers_automate[expression]
taken=True
dernier_expression = Automate.a_partir_de(resultat)
else:
if concat :
concat = False
resultat = GenerateurAutomate.faire_la_concatenation(Automate.a_partir_de(resultat), symbole_vers_automate[expression])
elif addition:
addition = False
resultat = GenerateurAutomate.faire_union(Automate.a_partir_de(resultat),
symbole_vers_automate[expression])
#resultat.visualiser()
return resultat
self.liste_automate[x].copie_automate(self.automate)
print(
[self.liste_automate[a].etat_initial for a in self.liste_automate])
alphabet = Alphabet([])
a = Etat('a')
b = Etat('b')
c = Etat('c')
t1 = Transition(a, '1', b)
t2 = Transition(a, '1', a)
t3 = Transition(a, '2', b)
t4 = Transition(b, '1', b)
automata = Automate(alphabet, [], None, [], [])
automata.definir_nom('Sans Nom')
liste_automate = {'Sans Nom': Automate.a_partir_de(automata)}
def run_app(automate=automata):
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow(automata, liste_automate)
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
if __name__ == "__main__":
run_app()