def readAutomato():
with open('InsiraSeuAutomatoAqui/automato.json') as file:
automatoJson = json.load(file)
alphabet = automatoJson["alfabeto"]
stateInitial = automatoJson["estadoInicial"]
stateEnd = automatoJson["estadoFinal"]
transictions = automatoJson["transicoes"]
newAutomato = Automato(alphabet, stateInitial, stateEnd, transictions)
newAutomato.populateTransictions()
return newAutomato
def main():
with open('automato.json') as f:
data = json.load(f)
alfabeto = data["alfabeto"]
listaTransicoes = data["listaTransicoes"]
estadoInicial = data["estadoInicial"]
estadoFinal = data["estadoFinal"]
automato = Automato(alfabeto, listaTransicoes, estadoInicial, estadoFinal)
automato.createAutomato()
while True:
print("1. - Testar Palavra")
print("2. - Minimizar Automato")
print("3. - Finalizar")
opc = int(input("opcao: "))
if opc == 1:
palavra = input("Informe a palavra: ")
automato.testarAutomato(palavra)
elif opc == 2:
automato.minimizacao()
elif opc == 3:
break
else:
print("Opção invalida")
def __init__(self, arq): self.reservadas = [] self.delimitadores = [] self.aut = Automato() self.arq = open(arq).readlines() self.linha_atual = 0 self.col_atual = 0
def automatoER(input):
input = entrytext.get()
l = Leitor(input)
dict, ini, final = l.ler()
a = Automato(dict,ini,final)
er = a.automataToER()
expressao = Er(er)
expressao.printER()
expressao.writeERToFile(input)
input = input.replace('.in', '')
data_file = open('../testes/'+input+'.out')
data = data_file.read()
data_file.close()
test = Tk.Tk()
Results = Tk.Label(test, text = data)
Results.grid(row = 20, column = 3, sticky= Tk.W)
def automatoGramatica(input):
l = Leitor(input)
dict, ini, final = l.ler()
a = Automato(dict,ini,final)
prod,terminais,nonTerminais,inicial = a.automataToGrammar()
g = Grammar(prod,terminais,nonTerminais,inicial)
g.printGrammar()
g.writeGrammarToFile(input)
input = input.replace('.in', '')
data_file = open('../testes/'+input+'.out')
data = data_file.read()
data_file.close()
test = Tk.Tk()
Results = Tk.Label(test, text = data)
Results.grid(row = 20, column = 3, sticky= Tk.W)
def gramaticaAutomato(input):
input = entrytext.get()
l = LeitorG(input)
dict, termi,nonter,ini = l.ler()
g = Grammar(dict,termi,nonter,ini)
s, inicial, final = g.convertGtoAF()
a = Automato(s,inicial,final)
a.printAtomato()
a.writeAutomataToFile(input)
input = input.replace('.in', '')
data_file = open('../testes/'+input+'.out')
data = data_file.read()
data_file.close()
test = Tk.Tk()
Results = Tk.Label(test, text = data)
Results.grid(row = 20, column = 3, sticky= Tk.W)
def main():
arquivo = FileStream("Automato.txt")
fita = input("Digite a fita de definicao:")
lexer = AutomatonGrammarLexer(arquivo)
stream = CommonTokenStream(lexer)
parser = AutomatonGrammarParser(stream)
tree = parser.s()
definicao = Listener()
walker = ParseTreeWalker()
walker.walk(definicao, tree)
definicao.transicoes = definicao.transicoes[0].replace(",(",
";(").split(";")
for cont in range(len(definicao.transicoes)):
definicao.transicoes[cont] = definicao.transicoes[cont].replace(
"(", "")
definicao.transicoes[cont] = definicao.transicoes[cont].replace(
")", "")
definicao.transicoes[cont] = definicao.transicoes[cont].replace(
"=", ",")
definicao.transicoes[cont] = definicao.transicoes[cont].split(",")
print("Alfabeto: ")
print(definicao.alfabeto)
print("Estados: ")
print(definicao.estados)
print("Transicoes: ")
print(definicao.transicoes)
print("Estado inicial: ")
print(definicao.inicio)
print("Estados Finais: ")
print(definicao.final)
auto = Automato(definicao, fita)
if auto.valida():
print("Entrada RECONHECIDA")
else:
print("Entrada NAO RECONHECIDA")
def complemento(old):
automato = Automato()
## percorre a lista e altera estados finais em normais
for e in old.estados:
if e.final:
e.final = False
automato.add_estado(e)
else:
e.final = True
automato.add_estado(e)
## coloca as transições no novo automato
automato.transicoes = old.transicoes
return automato
def determiniza(args):
input = entrytext.get()
l = Leitor(input)
dict, ini, final = l.ler()
a = Automato(dict,ini,final)
a.determina()
a.printAtomato()
a.writeAutomataToFile(input)
input = input.replace('.in', '')
data_file = open('../testes/'+input+'.out')
data = data_file.read()
data_file.close()
test = Tk.Tk()
Results = Tk.Label(test, text = data, )
Results.grid(row = 20, column = 3, sticky=(Tk.W, Tk.E))
def init(arquivo):
with open(arquivo) as arquivo:
linhas, estados, alfabeto, inicial, finais = getInput(arquivo)
automato = Automato(alfabeto, inicial, finais)
aplicaTransicoes(linhas, estados)
#Se o automato tiver todos os estados cadastrados, então o usuário poderá ler as palavras para teste
if (verificaAutomato(estados, alfabeto) == False):
res = input(
"Selecione a opção dessejada digitando o número da respectiva opção:\n"
+ "1: Para testar palavras no autômato\n" +
"2: Para mostrar estados equivalentes\n")
if res == "1":
lerPalavras(automato)
elif res == "2":
start(estados, automato)
def uniaoOu(a1, a2, tag):
novoAutomato = Automato(tag) #Cria um novo automato
#Adicionando todos os estados dos automatos antigos no novo
estados1 = a1.getEstados()
estados2 = a2.getEstados()
for estado in estados1:
novoAutomato.addEstado(estado)
for estado in estados2:
novoAutomato.addEstado(estado)
#Criando novos estados
novoInicial = Estado(True, False)
novoFinal = Estado(False, True)
novoAutomato.addEstado(novoInicial)
novoAutomato.addEstado(novoFinal)
novoAutomato.addEstadoInicial(novoInicial)
novoAutomato.addEstadoFinal(novoFinal)
#Criando novas transicoes para os estados iniciais
iniciais1 = a1.getEstadosIniciais()
iniciais2 = a2.getEstadosIniciais()
for estado in iniciais1:
t = Transicao(novoInicial, estado, '')
novoInicial.addTransicao(t)
estado.setInicial(False)
for estado in iniciais2:
t = Transicao(novoInicial, estado, '')
novoInicial.addTransicao(t)
estado.setInicial(False)
#Criando novas transicoes para os estados finais
finais1 = a1.getEstadosFinais()
finais2 = a2.getEstadosFinais()
for estado in finais1:
t = Transicao(estado, novoFinal, '')
estado.addTransicao(t)
estado.setFinal(False)
for estado in finais2:
t = Transicao(estado, novoFinal, '')
estado.addTransicao(t)
estado.setFinal(False)
novoAutomato.atualizaIds()
return novoAutomato
class Lexico(object):
#Delimitadores para transformar os varios em uma so transicao no automato
def __init__(self, arq):
self.reservadas = []
self.delimitadores = []
self.aut = Automato()
self.arq = open(arq).readlines()
self.linha_atual = 0
self.col_atual = 0
def insereEstado(self, est, final=False):
self.aut.insereEstado(est, final)
def insereTrans(self, est1, est2, simbolo):
self.aut.insereTrans(est1, est2, simbolo)
def setInicial(self, est):
self.aut.setInicial(est)
def insereDelimitador(self, dele):
self.delimitadores.append(dele)
def insereReservada(self, res):
self.reservadas.append(res)
#Retorna token se verdadeiro ou tupla com linha e coluna do erro, ex: ('ERRO', linha, coluna)
def scanner(self):
self.aut.resetInicial()
token = ''
#verifica se EOF
if self.linha_atual == len(self.arq):
return ('', 'EOF')
#verifica se newline
if self.arq[self.linha_atual][self.col_atual] == '\n':
self.linha_atual += 1
self.col_atual = 0
return('newline', 'QL')
#cria os tokens
for i in range(self.col_atual, len(self.arq[self.linha_atual])):
aux = self.arq[self.linha_atual][self.col_atual]
if (aux in self.delimitadores and token != '') and not self.aut.hasTrans(self.aut.returnAtual(), aux):
if self.aut.isFinal():
if token in self.reservadas:
return (token, token.upper())
else:
return (token, self.aut.returnAtual())
else:
raise Exception('ERRO - Lexico, identificador invalido', self.linha_atual+1, self.col_atual+1)
else:
valid = True
if aux not in self.delimitadores:
valid = self.aut.hasTrans(self.aut.returnAtual(), aux)
if valid:
token += aux
self.aut.doTrans(aux)
if not valid:
if self.aut.isFinal():
if token in self.reservadas:
return (token, token.upper())
else:
return (token, self.aut.returnAtual())
else:
raise Exception('ERRO - Lexico, estado nao eh final', self.linha_atual+1, self.col_atual+1)
self.col_atual += 1
#Entra somente no fim do arquivo
self.linha_atual += 1
if self.aut.isFinal():
if token in self.reservadas:
return (token, token.upper())
else:
return (token, self.aut.returnAtual())
else:
raise Exception('ERRO - Lexico, identificador invalido', self.linha_atual+1, self.col_atual+1)
def converteNFA(automato):
estados = automato.estados.copy()
finais = automato.finais.copy()
inicio = automato.inicio
n = 0
masksE = {}
etoi = {}
itoe = {}
for e in estados:
etoi[e] = n
itoe[n] = e
n += 1
for e in estados: masksE[e] = (1 << etoi[e])
finalizado = False
while not finalizado:
finalizado = True
for e in estados:
for caractere, estado in estados[e]:
if caractere == 'e':
velha_mask = masksE[e]
masksE[e] |= masksE[estado]
finalizado = finalizado and (velha_mask == masksE[e])
estadosF = {}
finaisF = []
inicioF = mask_to_str( (1 << etoi[inicio]) | masksE[inicio], n, itoe)
for mask in range(1 << n):
mask_str = mask_to_str(mask, n, itoe)
transicoes = ''
for estado in mask_str:
for transicao in estados[estado]:
if transicao[0] == 'e': continue
if transicao[0] in transicoes: continue
transicoes += transicao[0]
for char in transicoes:
goToMask = 0
for i in range(n):
if mask_possui_estado(mask, i):
e = itoe[i]
for caractere, novo_estado in estados[e]:
if caractere == 'e' or len(novo_estado) > 1: continue
if caractere == char:
goToMask |= (1 << etoi[novo_estado])
fo_to_mask_str = mask_to_str(goToMask, n, itoe)
if mask_str not in estadosF: estadosF[mask_str] = []
estadosF[mask_str].append( (char, fo_to_mask_str) )
for est_final in finais:
if est_final in mask_str:
finaisF.append(mask_str)
break
return Automato(estadosF, finaisF, inicioF)
import sys
from automato import Automato
if __name__ == "__main__":
arquivo_automato, palavra_input = sys.argv[1], sys.argv[2]
automato = Automato.ler_automato(arquivo_automato)
automato.checar_pertencimento(palavra_input)
if len(input) > 1: input, palavra = input[0], input[1:] + palavra
if (input == soma):
print("<soma, {}>".format(input))
proximo_estado = "Est1"
elif (input == subtracao):
print("<subtracao, {}>".format(input))
proximo_estado = "Est1"
elif (input == multiplicacao):
print("<multiplicacao, {}>".format(input))
proximo_estado = "Est1"
elif (input == divisao):
print("<divisao, {}>".format(input))
proximo_estado = "Est1"
elif len(input) == 0:
proximo_estado = "err"
else:
proximo_estado = "Est_erro"
return (proximo_estado, palavra)
if __name__ == "__main__":
m = Automato()
m.add_state("Est1", aceita_id)
m.add_state("Est2", aceita_op, end_state=1)
m.add_state("Est_erro", None, end_state=1)
m.add_state("err", None, end_state=1)
m.set_start("Est1")
inpt = input("Insira a expressão a ser analizada: ")
m.run(inpt)
def criar_automato(self):
a = Automato()
for terminal in self.tabela.x_rotulos:
a.inserir_terminal(terminal)
for estado in self.tabela.y_rotulos:
a.inserir_estado(estado.lstrip('->*'))
for i in range(self.tabela.n_linhas()):
line = self.tabela.get_linha(i)
atual = self.tabela.y_rotulos[i].lstrip('->*')
for j in range(len(line)):
terminal = self.tabela.x_rotulos[j]
final = line[j]
if final == '' or final == '-':
continue
for letra in final:
if final == 'Qerr':
break
if letra not in ascii_uppercase:
if letra not in ['@',',','&']:
self.msg('Transicao para nao-estado detectada.', atual+' + '+terminal+' = '+final)
return None
#Verificar se "final" esta na lista de estados
for item in final.split(','):
if item not in a.estados and item != '@':
self.msg('Transicao para um estado inexistente.', atual+' + '+terminal+' = '+final)
return None
a.inserir_transicao(atual, terminal, item)
a.inserir_estado_inicial(self.tabela.inicial)
for final in self.tabela.finais:
a.inserir_estado_final( final )
if self.tabela.finais == []:
self.msg('O automato deve ter ao menos um estado final.')
return None
if self.tabela.inicial == '':
self.msg('O automato deve ter um estado inicial.')
return None
return a
# -*- coding: utf-8 -*-
import sys
from automato import Automato
from autDet import AutomatoDeterminizado
from autDetE import AutomatoDeterminizadoEpsilon
entrada = sys.argv[1]
# Abre o arquivo
f = open(entrada + ".in")
Input = f.read()
tabela = []
exec(Input)
#Inicializa o automato
aut = Automato()
# Adiciona estado inicial, considerando que o primeiro sempre sera inicial
aut.estadoInicial(tabela[1][1])
# Adiciona o conjunto de simbolos sigma
for i in range(1, len(tabela[0])):
aut.adicionaSimbolo(tabela[0][i])
# Adiciona os estados presentes no automato e adiciona os estados finais
for i in range(1, len(tabela)):
if tabela[i][0] == "*":
aut.estadosFinais(tabela[i][1])
aut.adicionaEstado(tabela[i][1])
#Adiciona a tabela do arquivo ao automato como tabela de transicao de estados
#-*- coding: utf-8 -*-
from modulo import Estado, Transicao
import modulo
from automato import Automato
if __name__ == '__main__':
## criando um novo automato
a1 = Automato()
## Adicionando estados
a1.add_estado(Estado(id=0, name='q0', initial=True))
a1.add_estado(Estado(id=1, name='q1'))
a1.add_estado(Estado(id=2, name='q2', final=True))
## Exibindo estados
a1.print_estados()
## Adicionando transicoes
a1.add_transicao(
Transicao(de=a1.get_estado(name='q0'),
para=a1.get_estado(name='q1'),
ler='a'))
a1.add_transicao(
Transicao(de=a1.get_estado(name='q0'),
para=a1.get_estado(name='q0'),
ler='b'))
a1.add_transicao(
Transicao(de=a1.get_estado(name='q1'),
para=a1.get_estado(name='q2'),
ler='a'))
def multiplicar(a1,a2):
# novo automato
new = Automato()
# Alfabeto é a combinação dos simbolos dos dois
new.alfabeto = set(a1.alfabeto+a2.alfabeto)
## concatenando os nomes
for e1 in a1.estados:
for e2 in a2.estados:
## novo estados
new_id = str(e1.id) + str(e2.id)
new_name = e1.name + e2.name
## se for estado inicial
if e1.initial and e2.initial:
new.add_estado(Estado(name=new_name,id=new_id,initial=True))
## se forem estados finais
#elif e1.final or e2.final:
# new.add_estado(Estado(name=new_name,id=new_id,final=True))
## se não é normal
else: new.add_estado(Estado(name=new_name,id=new_id))
## fim for
## Outro for para fazer as transições, irá combinar leituras com os estados
for a in new.alfabeto:
for e1 in a1.estados:
for e2 in a2.estados:
estado_de = new.get_estado(name=str(e1.name)+str(e2.name))
estado_para = None
p1 = a1.mover_name(e1.name,a)
p2 = a2.mover_name(e2.name,a)
## se encontrar busca o estado
if p1 and p2:
estado_para = new.get_estado(name=p1+p2)
## cria tansicao
new.add_transicao( Transicao(de=estado_de,para=estado_para,ler=a) )
return new
def init():
estados, inicial, aceita, transicoes, palavra, segundoArquivo = entrada()
automato = Automato(estados, inicial, aceita, transicoes)
if not "-" in palavra:
automato.execultar(palavra)
else:
if palavra == "-uniao":
estados, inicial, aceita, transicoes = parseEntrada(segundoArquivo)
segundo_automato = Automato(estados, inicial, aceita, transicoes)
automato.getUniao(segundo_automato)
elif palavra == "-complemento":
automato.getComplemento()
elif palavra == "-estrela":
automato.getEstrela()
elif palavra == "-intercecao":
automato.getIntercecao()
elif palavra == "-complemento":
automato.complemento()
elif palavra == "-AFD":
automato.getAFD()
elif palavra == "-minimizacao":
automato.getMinimizacao()
def automatoSimples(simbolo, tag):
automato = Automato(tag) #Cria um novo automato
eInicial = Estado(True, False) #Cria um estado inicial
eFinal = Estado(False, True) #Cria um estado final
#Adiciona os estados no automato
automato.addEstado(eInicial)
automato.addEstado(eFinal)
automato.addEstadoInicial(eInicial)
automato.addEstadoFinal(eFinal)
transicao = Transicao(
eInicial, eFinal,
simbolo) #Cria uma transicao entre o estado final e inicial
eInicial.addTransicao(
transicao
) #Adiciona a transicao na lista de transicoes do estado inicial
automato.atualizaIds()
return automato
def uniaoE(a1, a2, tag):
novoAutomato = Automato(tag) #Cria um novo automato
#Adicionando todos os estados dos automatos antigos no novo
estados1 = a1.getEstados()
estados2 = a2.getEstados()
for estado in estados1:
novoAutomato.addEstado(estado)
for estado in estados2:
novoAutomato.addEstado(estado)
#Adicionando todos os estados iniciais de a1 como estados iniciais do novo automato
for estado in a1.getEstadosIniciais():
novoAutomato.addEstadoInicial(estado)
#Fazendo todos os estados finais de a1 apontarem para os estados iniciais de a2
for estadoFinal in a1.getEstadosFinais():
estadoFinal.setFinal(False)
for estadoInicial in a2.getEstadosIniciais():
estadoInicial.setInicial(False)
t = Transicao(estadoFinal, estadoInicial, '')
estadoFinal.addTransicao(t)
#Adicionando todos os estados finais de a2 na lista de estados finais do novo automato
for estadoFinal in a2.getEstadosFinais():
novoAutomato.addEstadoFinal(estadoFinal)
novoAutomato.atualizaIds()
return novoAutomato
import json
from automato import Automato
from time import sleep
from lib.interface import menu, cabecalho
cabecalho(f'{"="*20} Pytomatos {"="*20}')
while True:
automato = Automato('automato.json')
resposta = menu(
['Imprimir detalhes do autômato', 'Testar palavra', 'Sair do sistema'])
if resposta == 1:
print()
cabecalho('Opção 1 - Imprimir detalhes do autômato')
if automato.tipo == 'afn':
print(automato)
sleep(1)
print('Convertendo o autômato para AFD...')
print()
automato.converter_afn_afd()
sleep(1)
print(f'Autômato convertido: \n{automato}')
else:
print(automato)
sleep(1)
elif resposta == 2:
print()
cabecalho('Opção 2 - Testar palavra')
def inicia(self):
case = 0
lex = Lex()
# # 1 ER PALAVRAS RESERVADAS
a1 = lex.lexer('reservado', case)
dict = a1.getDictAutomato()
case += len(dict)
# # 2 ER IDENTIFICADORES
a2 = lex.lexer('identificadores', case)
# # 3 GRAMATICA DE SESPECIAL
terminais = ['+', '-', '=', '/', '*', '>', '<', '!']
nTerminais = ['S']
producoes = {'S': ['+', '-', '=', '/', '*', '>', '<', '!']}
inicial = 'S'
g = Grammar(producoes,terminais, nTerminais, inicial)
s, i, f = g.convertGtoAF()
a3 = Automato(s, i, f)
a3.determina()
a3.printAtomato()
print("\n")
dict = a2.getDictAutomato()
case += len(dict)
a3 = lex.renameState(a3, case)
# # 4 GRAMATICA SEPARADORES
terminais2 = [':',';', ' ', '(', ')', '[', ']', ',', '\n']
nTerminais2 = ['S']
producoes2 = {'S': [':',';', ' ', '(', ')', '[', ']', ',', '\n']}
inicial2 = 'S'
g = Grammar(producoes2,terminais2, nTerminais2, inicial2)
s2, i2, f2 = g.convertGtoAF()
a4 = Automato(s2, i2, f2)
a4.determina()
a4.printAtomato()
print("\n")
dict = a3.getDictAutomato()
case += len(dict)
a4 = lex.renameState(a4, case)
# ER CONSTANTES
dict = a4.getDictAutomato()
case += len(dict)
a5 = lex.lexer('constantes', case)
r = a5
r = a1.oU([a2, a3, a4, a5])
print ("\n")
r.determina()
r.printAtomato()
with open('automato.pkl', 'wb') as output:
pickle.dump(r, output, pickle.HIGHEST_PROTOCOL)
import sys
from automato import Automato
if __name__ == "__main__":
arquivo_automato1, arquivo_automato2 = sys.argv[1], sys.argv[2]
automato1 = Automato.ler_automato(arquivo_automato1)
automato2 = Automato.ler_automato(arquivo_automato2)
automato_uniao = automato1.uniao(automato2)
print(automato_uniao)