def _nao_terminal(self, estado, terminal, nao_term):
flag = False
tem_nao_term = False
indice = 0
rotulo = 0
for est in self.estados:
if est.rotuloGr != estado:
indice += 1
if est.rotuloGr == nao_term:
tem_nao_term = True
rotulo = est.rotulo
for prox_estado in self.estados[indice].transicoes:
if prox_estado.rotulo == terminal:
flag = True
if tem_nao_term:
if rotulo not in prox_estado.transicoes:
prox_estado.transicoes.append(rotulo)
else:
prox_estado.transicoes.append(self._count_estado)
self._add_estado(nao_term)
break
if not flag:
transicao = Transicao()
transicao.rotulo = terminal
if tem_nao_term:
transicao.transicoes.append(rotulo)
else:
transicao.transicoes.append(self._count_estado)
self._add_estado(nao_term)
self.estados[indice].transicoes.append(transicao)
def addTransicao(self, segFita, partida, destino, simboloAtual,
simboloNovo, movimento, nomeDoBloco, pause):
blocoLocal = self.pegaOBloco(nomeDoBloco)
# Adiciona simbolo no alfabeto do simulador da maquina
if (simboloAtual not in self.alfabeto):
self.alfabeto.append(simboloAtual)
blocoLocal.addEstado(partida)
blocoLocal.addEstado(destino)
blocoLocal.addnoAlfabeto(simboloAtual)
blocoLocal.addoutAlfabeto(simboloNovo)
movement = ""
if (movimento == 'e'):
movement = Fita.MOVE_ESQUERDA
elif (movimento == 'd'):
movement = Fita.MOVE_DIREITA
else:
movement = Fita.IMOVEL
novaTrans = Transicao(segFita, partida, destino, simboloAtual,
simboloNovo, movement, pause)
blocoLocal.addTransicao(novaTrans)
return
def ler_arquivo(arquivo: str):
configuracoes = json.loads(
open(file=arquivo, mode="r", encoding="UTF-8").read())
lugares = {}
transicoes = {}
for lugar_conf in configuracoes["lugares"]:
lugar = Lugar(lugar_conf)
lugares[lugar.id] = lugar
for transacao_conf in configuracoes["transicoes"]:
transicao = Transicao(transacao_conf)
transicoes[transicao.id] = transicao
for arco_conf in configuracoes["arcos"]:
id_origem = arco_conf["origem"]
id_destino = arco_conf["destino"]
peso = arco_conf["peso"]
if id_origem in lugares:
origem = lugares[id_origem]
destino = transicoes[id_destino]
else:
origem = transicoes[id_origem]
destino = lugares[id_destino]
origem.destinos.append({"peso": peso, "destino": destino})
destino.origens.append({"peso": peso, "origem": origem})
return {"lugares": lugares, "transicoes": transicoes}
def uniaoA(a1):
eIniciais = a1.getEstadosIniciais()
eFinais = a1.getEstadosFinais()
for final in eFinais:
for inicial in eIniciais:
t = Transicao(final, inicial, '')
final.addTransicao(t)
a1.atualizaIds()
return a1
def _terminal(self, estado, terminal):
indice = 0
flag = False
for est in self.estados:
if est.rotuloGr == estado:
break
indice += 1
for prox_estado in self.estados[indice].transicoes:
if prox_estado.rotulo == terminal:
flag = True
prox_estado.transicoes.append(self._count_estado)
if not flag:
transicao = Transicao()
transicao.rotulo = terminal
transicao.transicoes.append(self._count_estado)
est = self._add_estado("")
est.final = True
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
def __init__(self, nome=None):
self.letra_estado = 'q'
self.inicio = self.letra_estado+(str(0))
if(nome != None):
self.lista_fim = [self.letra_estado+(str(1))]
self.lista_estado = [self.inicio, self.lista_fim[0]]
transicao = Transicao(self.inicio, nome, self.lista_fim[0])
self.lista_transicao = [transicao]
self.alfabeto = [transicao.nome]
else:
self.lista_estado = []
self.lista_transicao = list()
self.alfabeto = list()
self.lista_fim = list()
def __init__(self, dados, entrada):
self.entrada = [entry for entry in entrada]
self.alfabeto_entrada = dados['alfabeto_entrada']
self.alfabeto_pilha = dados['alfabeto_pilha']
self.epsilon = dados['epsilon']
self.inicial_pilha = dados['inicial_pilha']
self.estados_tmp = dados['estados'] ## nomes dos estados
self.estado_inicial = dados['estado_inicial']
self.estados_finais = dados['estados_finais']
self.transicoes_tmp = dados[
'transicoes'] ## dicts temporarios das transicoes
#### Atribuicao dos dados simples ####
self.estados = []
for state in self.estados_tmp: ## criar objetos de estado
estado = Estado(state)
if state == self.estado_inicial: ## setar estado inicial
self.estado_atual = estado
estado.set_inicial()
if state in self.estados_finais: ## setar estado(s) final(is)
estado.set_final()
self.estados.append(estado)
self.transicoes = []
for transition in self.transicoes_tmp: ## criar objetos de transicao
for i in self.estados:
if i.get_nome() == transition[
'estado_atual']: ## atribuir estado a transicao
cur_state = i
if i.get_nome() == transition[
'estado_destino']: ## atribuir estado a transicao
new_state = i
simbol_ent = transition['simbolo_corrente']
simbols_stack = transition['pop_pilha']
new_simbols_stack = transition['push_pilha']
## adicionar uma transicao a lista de transicoes
self.transicoes.append(
Transicao(cur_state, simbol_ent, simbols_stack, new_state,
new_simbols_stack))
## cria a primeira execucao
self.execucoes = [
Algoz(self.entrada, Pilha(self.inicial_pilha), self.estado_atual,
self.epsilon)
]
def addTransicao(self, origem, nome, destino):
if isinstance(origem, int):
origem = self.letra_estado+str(origem)
if isinstance(destino, int):
destino = self.letra_estado+str(destino)
if(self.origem_destino(origem, nome, destino) == False):
if(self.getEstado(origem) == False):
self.addEstado(origem)
if(self.getEstado(destino) == False):
self.addEstado(destino)
transicao = Transicao(origem, nome, destino)
self.lista_transicao.append(transicao)
if(transicao.nome != self.epsilon()):
if(transicao.nome not in self.alfabeto):
self.alfabeto.append(transicao.nome)
return True
return False
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 retira_informacoes(self):
AUTOMATO = 0
TRANSICOES_INIC = 2
num_linha = 0
transicoes = []
for linha in self.texto_automato:
if num_linha == AUTOMATO:
posicao_inicial = linha.index('=') + 1
automato = linha[posicao_inicial:]
elif num_linha >= TRANSICOES_INIC:
transicao = Transicao(linha.replace('\n', ''))
transicoes.append(transicao)
num_linha += 1
return automato, transicoes
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
def _adicionaTransicao(
self, encontrou, substitui, estadoOrigem, estadoDestino,
direcaoFita): #Adiciona uma transição para algum estado
self.estados[estadoOrigem].adicionaTransicao(
Transicao(encontrou, substitui, estadoOrigem, estadoDestino,
direcaoFita))